summaryrefslogtreecommitdiffstats
path: root/task1/ehr.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'task1/ehr.cpp')
-rw-r--r--task1/ehr.cpp6836
1 files changed, 0 insertions, 6836 deletions
diff --git a/task1/ehr.cpp b/task1/ehr.cpp
deleted file mode 100644
index 29b45e9..0000000
--- a/task1/ehr.cpp
+++ /dev/null
@@ -1,6836 +0,0 @@
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#include <ehr.h>
14#include <Ice/LocalException.h>
15#include <Ice/ObjectFactory.h>
16#include <Ice/BasicStream.h>
17#include <Ice/Stream.h>
18#include <IceUtil/Iterator.h>
19#include <IceUtil/ScopedArray.h>
20
21#ifndef ICE_IGNORE_VERSION
22# if ICE_INT_VERSION / 100 != 303
23# error Ice version mismatch!
24# endif
25# if ICE_INT_VERSION % 100 > 50
26# error Beta header file detected
27# endif
28# if ICE_INT_VERSION % 100 < 1
29# error Ice patch level mismatch!
30# endif
31#endif
32
33static const ::std::string __Ehr__Provider__createPrescription_name = "createPrescription";
34
35static const ::std::string __Ehr__Provider__consumePrescription_name = "consumePrescription";
36
37static const ::std::string __Ehr__Provider__listDocuments_name = "listDocuments";
38
39static const ::std::string __Ehr__Provider__findDocuments_name = "findDocuments";
40
41static const ::std::string __Ehr__Provider__setDefaultAccess_name = "setDefaultAccess";
42
43static const ::std::string __Ehr__Provider__createPermission_name = "createPermission";
44
45static const ::std::string __Ehr__Provider__listPermissions_name = "listPermissions";
46
47static const ::std::string __Ehr__Provider__removePermission_name = "removePermission";
48
49::Ice::Object* IceInternal::upCast(::Ehr::Document* p) { return p; }
50::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Document* p) { return p; }
51
52::Ice::Object* IceInternal::upCast(::Ehr::Prescription* p) { return p; }
53::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Prescription* p) { return p; }
54
55::Ice::Object* IceInternal::upCast(::Ehr::ConsumedPrescription* p) { return p; }
56::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumedPrescription* p) { return p; }
57
58::Ice::Object* IceInternal::upCast(::Ehr::Request* p) { return p; }
59::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Request* p) { return p; }
60
61::Ice::Object* IceInternal::upCast(::Ehr::ThirdPartyRequest* p) { return p; }
62::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ThirdPartyRequest* p) { return p; }
63
64::Ice::Object* IceInternal::upCast(::Ehr::CreatePrescriptionRequest* p) { return p; }
65::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePrescriptionRequest* p) { return p; }
66
67::Ice::Object* IceInternal::upCast(::Ehr::ConsumePrescriptionRequest* p) { return p; }
68::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumePrescriptionRequest* p) { return p; }
69
70::Ice::Object* IceInternal::upCast(::Ehr::ListDocumentsRequest* p) { return p; }
71::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListDocumentsRequest* p) { return p; }
72
73::Ice::Object* IceInternal::upCast(::Ehr::FindDocumentsRequest* p) { return p; }
74::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::FindDocumentsRequest* p) { return p; }
75
76::Ice::Object* IceInternal::upCast(::Ehr::CreatePermissionRequest* p) { return p; }
77::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePermissionRequest* p) { return p; }
78
79::Ice::Object* IceInternal::upCast(::Ehr::SetDefaultAccessRequest* p) { return p; }
80::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::SetDefaultAccessRequest* p) { return p; }
81
82::Ice::Object* IceInternal::upCast(::Ehr::ListPermissionsRequest* p) { return p; }
83::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListPermissionsRequest* p) { return p; }
84
85::Ice::Object* IceInternal::upCast(::Ehr::RemovePermissionRequest* p) { return p; }
86::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::RemovePermissionRequest* p) { return p; }
87
88::Ice::Object* IceInternal::upCast(::Ehr::Provider* p) { return p; }
89::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Provider* p) { return p; }
90
91void
92Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentPrx& v)
93{
94 ::Ice::ObjectPrx proxy;
95 __is->read(proxy);
96 if(!proxy)
97 {
98 v = 0;
99 }
100 else
101 {
102 v = new ::IceProxy::Ehr::Document;
103 v->__copyFrom(proxy);
104 }
105}
106
107void
108Ehr::ice_writeDocumentPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPrx& v)
109{
110 __outS->writeProxy(v);
111}
112
113void
114Ehr::ice_readDocumentPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPrx& v)
115{
116 ::Ice::ObjectPrx proxy = __inS->readProxy();
117 if(!proxy)
118 {
119 v = 0;
120 }
121 else
122 {
123 v = new ::IceProxy::Ehr::Document;
124 v->__copyFrom(proxy);
125 }
126}
127
128void
129Ehr::ice_writeDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPtr& v)
130{
131 __outS->writeObject(v);
132}
133
134void
135Ehr::ice_readDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPtr& __v)
136{
137 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__DocumentPtr, &__v);
138 __inS->readObject(__cb);
139}
140
141void
142Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::PrescriptionPrx& v)
143{
144 ::Ice::ObjectPrx proxy;
145 __is->read(proxy);
146 if(!proxy)
147 {
148 v = 0;
149 }
150 else
151 {
152 v = new ::IceProxy::Ehr::Prescription;
153 v->__copyFrom(proxy);
154 }
155}
156
157void
158Ehr::ice_writePrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPrx& v)
159{
160 __outS->writeProxy(v);
161}
162
163void
164Ehr::ice_readPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPrx& v)
165{
166 ::Ice::ObjectPrx proxy = __inS->readProxy();
167 if(!proxy)
168 {
169 v = 0;
170 }
171 else
172 {
173 v = new ::IceProxy::Ehr::Prescription;
174 v->__copyFrom(proxy);
175 }
176}
177
178void
179Ehr::ice_writePrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPtr& v)
180{
181 __outS->writeObject(v);
182}
183
184void
185Ehr::ice_readPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPtr& __v)
186{
187 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__PrescriptionPtr, &__v);
188 __inS->readObject(__cb);
189}
190
191void
192Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumedPrescriptionPrx& v)
193{
194 ::Ice::ObjectPrx proxy;
195 __is->read(proxy);
196 if(!proxy)
197 {
198 v = 0;
199 }
200 else
201 {
202 v = new ::IceProxy::Ehr::ConsumedPrescription;
203 v->__copyFrom(proxy);
204 }
205}
206
207void
208Ehr::ice_writeConsumedPrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPrx& v)
209{
210 __outS->writeProxy(v);
211}
212
213void
214Ehr::ice_readConsumedPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPrx& v)
215{
216 ::Ice::ObjectPrx proxy = __inS->readProxy();
217 if(!proxy)
218 {
219 v = 0;
220 }
221 else
222 {
223 v = new ::IceProxy::Ehr::ConsumedPrescription;
224 v->__copyFrom(proxy);
225 }
226}
227
228void
229Ehr::ice_writeConsumedPrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPtr& v)
230{
231 __outS->writeObject(v);
232}
233
234void
235Ehr::ice_readConsumedPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPtr& __v)
236{
237 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumedPrescriptionPtr, &__v);
238 __inS->readObject(__cb);
239}
240
241void
242Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RequestPrx& v)
243{
244 ::Ice::ObjectPrx proxy;
245 __is->read(proxy);
246 if(!proxy)
247 {
248 v = 0;
249 }
250 else
251 {
252 v = new ::IceProxy::Ehr::Request;
253 v->__copyFrom(proxy);
254 }
255}
256
257void
258Ehr::ice_writeRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPrx& v)
259{
260 __outS->writeProxy(v);
261}
262
263void
264Ehr::ice_readRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPrx& v)
265{
266 ::Ice::ObjectPrx proxy = __inS->readProxy();
267 if(!proxy)
268 {
269 v = 0;
270 }
271 else
272 {
273 v = new ::IceProxy::Ehr::Request;
274 v->__copyFrom(proxy);
275 }
276}
277
278void
279Ehr::ice_writeRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPtr& v)
280{
281 __outS->writeObject(v);
282}
283
284void
285Ehr::ice_readRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPtr& __v)
286{
287 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RequestPtr, &__v);
288 __inS->readObject(__cb);
289}
290
291void
292Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ThirdPartyRequestPrx& v)
293{
294 ::Ice::ObjectPrx proxy;
295 __is->read(proxy);
296 if(!proxy)
297 {
298 v = 0;
299 }
300 else
301 {
302 v = new ::IceProxy::Ehr::ThirdPartyRequest;
303 v->__copyFrom(proxy);
304 }
305}
306
307void
308Ehr::ice_writeThirdPartyRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPrx& v)
309{
310 __outS->writeProxy(v);
311}
312
313void
314Ehr::ice_readThirdPartyRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPrx& v)
315{
316 ::Ice::ObjectPrx proxy = __inS->readProxy();
317 if(!proxy)
318 {
319 v = 0;
320 }
321 else
322 {
323 v = new ::IceProxy::Ehr::ThirdPartyRequest;
324 v->__copyFrom(proxy);
325 }
326}
327
328void
329Ehr::ice_writeThirdPartyRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPtr& v)
330{
331 __outS->writeObject(v);
332}
333
334void
335Ehr::ice_readThirdPartyRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPtr& __v)
336{
337 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ThirdPartyRequestPtr, &__v);
338 __inS->readObject(__cb);
339}
340
341void
342Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePrescriptionRequestPrx& v)
343{
344 ::Ice::ObjectPrx proxy;
345 __is->read(proxy);
346 if(!proxy)
347 {
348 v = 0;
349 }
350 else
351 {
352 v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
353 v->__copyFrom(proxy);
354 }
355}
356
357void
358Ehr::ice_writeCreatePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPrx& v)
359{
360 __outS->writeProxy(v);
361}
362
363void
364Ehr::ice_readCreatePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPrx& v)
365{
366 ::Ice::ObjectPrx proxy = __inS->readProxy();
367 if(!proxy)
368 {
369 v = 0;
370 }
371 else
372 {
373 v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
374 v->__copyFrom(proxy);
375 }
376}
377
378void
379Ehr::ice_writeCreatePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPtr& v)
380{
381 __outS->writeObject(v);
382}
383
384void
385Ehr::ice_readCreatePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPtr& __v)
386{
387 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePrescriptionRequestPtr, &__v);
388 __inS->readObject(__cb);
389}
390
391void
392Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumePrescriptionRequestPrx& v)
393{
394 ::Ice::ObjectPrx proxy;
395 __is->read(proxy);
396 if(!proxy)
397 {
398 v = 0;
399 }
400 else
401 {
402 v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
403 v->__copyFrom(proxy);
404 }
405}
406
407void
408Ehr::ice_writeConsumePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPrx& v)
409{
410 __outS->writeProxy(v);
411}
412
413void
414Ehr::ice_readConsumePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPrx& v)
415{
416 ::Ice::ObjectPrx proxy = __inS->readProxy();
417 if(!proxy)
418 {
419 v = 0;
420 }
421 else
422 {
423 v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
424 v->__copyFrom(proxy);
425 }
426}
427
428void
429Ehr::ice_writeConsumePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPtr& v)
430{
431 __outS->writeObject(v);
432}
433
434void
435Ehr::ice_readConsumePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPtr& __v)
436{
437 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumePrescriptionRequestPtr, &__v);
438 __inS->readObject(__cb);
439}
440
441void
442Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListDocumentsRequestPrx& v)
443{
444 ::Ice::ObjectPrx proxy;
445 __is->read(proxy);
446 if(!proxy)
447 {
448 v = 0;
449 }
450 else
451 {
452 v = new ::IceProxy::Ehr::ListDocumentsRequest;
453 v->__copyFrom(proxy);
454 }
455}
456
457void
458Ehr::ice_writeListDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPrx& v)
459{
460 __outS->writeProxy(v);
461}
462
463void
464Ehr::ice_readListDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPrx& v)
465{
466 ::Ice::ObjectPrx proxy = __inS->readProxy();
467 if(!proxy)
468 {
469 v = 0;
470 }
471 else
472 {
473 v = new ::IceProxy::Ehr::ListDocumentsRequest;
474 v->__copyFrom(proxy);
475 }
476}
477
478void
479Ehr::ice_writeListDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPtr& v)
480{
481 __outS->writeObject(v);
482}
483
484void
485Ehr::ice_readListDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPtr& __v)
486{
487 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListDocumentsRequestPtr, &__v);
488 __inS->readObject(__cb);
489}
490
491void
492Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::FindDocumentsRequestPrx& v)
493{
494 ::Ice::ObjectPrx proxy;
495 __is->read(proxy);
496 if(!proxy)
497 {
498 v = 0;
499 }
500 else
501 {
502 v = new ::IceProxy::Ehr::FindDocumentsRequest;
503 v->__copyFrom(proxy);
504 }
505}
506
507void
508Ehr::ice_writeFindDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPrx& v)
509{
510 __outS->writeProxy(v);
511}
512
513void
514Ehr::ice_readFindDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPrx& v)
515{
516 ::Ice::ObjectPrx proxy = __inS->readProxy();
517 if(!proxy)
518 {
519 v = 0;
520 }
521 else
522 {
523 v = new ::IceProxy::Ehr::FindDocumentsRequest;
524 v->__copyFrom(proxy);
525 }
526}
527
528void
529Ehr::ice_writeFindDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPtr& v)
530{
531 __outS->writeObject(v);
532}
533
534void
535Ehr::ice_readFindDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPtr& __v)
536{
537 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__FindDocumentsRequestPtr, &__v);
538 __inS->readObject(__cb);
539}
540
541void
542Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePermissionRequestPrx& v)
543{
544 ::Ice::ObjectPrx proxy;
545 __is->read(proxy);
546 if(!proxy)
547 {
548 v = 0;
549 }
550 else
551 {
552 v = new ::IceProxy::Ehr::CreatePermissionRequest;
553 v->__copyFrom(proxy);
554 }
555}
556
557void
558Ehr::ice_writeCreatePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPrx& v)
559{
560 __outS->writeProxy(v);
561}
562
563void
564Ehr::ice_readCreatePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPrx& v)
565{
566 ::Ice::ObjectPrx proxy = __inS->readProxy();
567 if(!proxy)
568 {
569 v = 0;
570 }
571 else
572 {
573 v = new ::IceProxy::Ehr::CreatePermissionRequest;
574 v->__copyFrom(proxy);
575 }
576}
577
578void
579Ehr::ice_writeCreatePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPtr& v)
580{
581 __outS->writeObject(v);
582}
583
584void
585Ehr::ice_readCreatePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPtr& __v)
586{
587 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePermissionRequestPtr, &__v);
588 __inS->readObject(__cb);
589}
590
591void
592Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::SetDefaultAccessRequestPrx& v)
593{
594 ::Ice::ObjectPrx proxy;
595 __is->read(proxy);
596 if(!proxy)
597 {
598 v = 0;
599 }
600 else
601 {
602 v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
603 v->__copyFrom(proxy);
604 }
605}
606
607void
608Ehr::ice_writeSetDefaultAccessRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPrx& v)
609{
610 __outS->writeProxy(v);
611}
612
613void
614Ehr::ice_readSetDefaultAccessRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPrx& v)
615{
616 ::Ice::ObjectPrx proxy = __inS->readProxy();
617 if(!proxy)
618 {
619 v = 0;
620 }
621 else
622 {
623 v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
624 v->__copyFrom(proxy);
625 }
626}
627
628void
629Ehr::ice_writeSetDefaultAccessRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPtr& v)
630{
631 __outS->writeObject(v);
632}
633
634void
635Ehr::ice_readSetDefaultAccessRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPtr& __v)
636{
637 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__SetDefaultAccessRequestPtr, &__v);
638 __inS->readObject(__cb);
639}
640
641void
642Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListPermissionsRequestPrx& v)
643{
644 ::Ice::ObjectPrx proxy;
645 __is->read(proxy);
646 if(!proxy)
647 {
648 v = 0;
649 }
650 else
651 {
652 v = new ::IceProxy::Ehr::ListPermissionsRequest;
653 v->__copyFrom(proxy);
654 }
655}
656
657void
658Ehr::ice_writeListPermissionsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPrx& v)
659{
660 __outS->writeProxy(v);
661}
662
663void
664Ehr::ice_readListPermissionsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPrx& v)
665{
666 ::Ice::ObjectPrx proxy = __inS->readProxy();
667 if(!proxy)
668 {
669 v = 0;
670 }
671 else
672 {
673 v = new ::IceProxy::Ehr::ListPermissionsRequest;
674 v->__copyFrom(proxy);
675 }
676}
677
678void
679Ehr::ice_writeListPermissionsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPtr& v)
680{
681 __outS->writeObject(v);
682}
683
684void
685Ehr::ice_readListPermissionsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPtr& __v)
686{
687 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListPermissionsRequestPtr, &__v);
688 __inS->readObject(__cb);
689}
690
691void
692Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RemovePermissionRequestPrx& v)
693{
694 ::Ice::ObjectPrx proxy;
695 __is->read(proxy);
696 if(!proxy)
697 {
698 v = 0;
699 }
700 else
701 {
702 v = new ::IceProxy::Ehr::RemovePermissionRequest;
703 v->__copyFrom(proxy);
704 }
705}
706
707void
708Ehr::ice_writeRemovePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPrx& v)
709{
710 __outS->writeProxy(v);
711}
712
713void
714Ehr::ice_readRemovePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPrx& v)
715{
716 ::Ice::ObjectPrx proxy = __inS->readProxy();
717 if(!proxy)
718 {
719 v = 0;
720 }
721 else
722 {
723 v = new ::IceProxy::Ehr::RemovePermissionRequest;
724 v->__copyFrom(proxy);
725 }
726}
727
728void
729Ehr::ice_writeRemovePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPtr& v)
730{
731 __outS->writeObject(v);
732}
733
734void
735Ehr::ice_readRemovePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPtr& __v)
736{
737 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RemovePermissionRequestPtr, &__v);
738 __inS->readObject(__cb);
739}
740
741void
742Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ProviderPrx& v)
743{
744 ::Ice::ObjectPrx proxy;
745 __is->read(proxy);
746 if(!proxy)
747 {
748 v = 0;
749 }
750 else
751 {
752 v = new ::IceProxy::Ehr::Provider;
753 v->__copyFrom(proxy);
754 }
755}
756
757void
758Ehr::ice_writeProviderPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPrx& v)
759{
760 __outS->writeProxy(v);
761}
762
763void
764Ehr::ice_readProviderPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPrx& v)
765{
766 ::Ice::ObjectPrx proxy = __inS->readProxy();
767 if(!proxy)
768 {
769 v = 0;
770 }
771 else
772 {
773 v = new ::IceProxy::Ehr::Provider;
774 v->__copyFrom(proxy);
775 }
776}
777
778void
779Ehr::ice_writeProvider(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPtr& v)
780{
781 __outS->writeObject(v);
782}
783
784void
785Ehr::ice_readProvider(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPtr& __v)
786{
787 ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ProviderPtr, &__v);
788 __inS->readObject(__cb);
789}
790
791Ehr::EhrException::EhrException(const ::std::string& __ice_what) :
792#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
793 UserException(),
794#else
795 ::Ice::UserException(),
796#endif
797 what(__ice_what)
798{
799}
800
801Ehr::EhrException::~EhrException() throw()
802{
803}
804
805static const char* __Ehr__EhrException_name = "Ehr::EhrException";
806
807::std::string
808Ehr::EhrException::ice_name() const
809{
810 return __Ehr__EhrException_name;
811}
812
813::Ice::Exception*
814Ehr::EhrException::ice_clone() const
815{
816 return new EhrException(*this);
817}
818
819void
820Ehr::EhrException::ice_throw() const
821{
822 throw *this;
823}
824
825void
826Ehr::EhrException::__write(::IceInternal::BasicStream* __os) const
827{
828 __os->write(::std::string("::Ehr::EhrException"), false);
829 __os->startWriteSlice();
830 __os->write(what);
831 __os->endWriteSlice();
832}
833
834void
835Ehr::EhrException::__read(::IceInternal::BasicStream* __is, bool __rid)
836{
837 if(__rid)
838 {
839 ::std::string myId;
840 __is->read(myId, false);
841 }
842 __is->startReadSlice();
843 __is->read(what);
844 __is->endReadSlice();
845}
846
847void
848Ehr::EhrException::__write(const ::Ice::OutputStreamPtr& __outS) const
849{
850 __outS->writeString(::std::string("::Ehr::EhrException"));
851 __outS->startSlice();
852 __outS->writeString(what);
853 __outS->endSlice();
854}
855
856void
857Ehr::EhrException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
858{
859 if(__rid)
860 {
861 __inS->readString();
862 }
863 __inS->startSlice();
864 what = __inS->readString();
865 __inS->endSlice();
866}
867
868struct __F__Ehr__EhrException : public ::IceInternal::UserExceptionFactory
869{
870 virtual void
871 createAndThrow()
872 {
873 throw ::Ehr::EhrException();
874 }
875};
876
877static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__EhrException__Ptr = new __F__Ehr__EhrException;
878
879const ::IceInternal::UserExceptionFactoryPtr&
880Ehr::EhrException::ice_factory()
881{
882 return __F__Ehr__EhrException__Ptr;
883}
884
885class __F__Ehr__EhrException__Init
886{
887public:
888
889 __F__Ehr__EhrException__Init()
890 {
891 ::IceInternal::factoryTable->addExceptionFactory("::Ehr::EhrException", ::Ehr::EhrException::ice_factory());
892 }
893
894 ~__F__Ehr__EhrException__Init()
895 {
896 ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::EhrException");
897 }
898};
899
900static __F__Ehr__EhrException__Init __F__Ehr__EhrException__i;
901
902#ifdef __APPLE__
903extern "C" { void __F__Ehr__EhrException__initializer() {} }
904#endif
905
906Ehr::InvalidRequestException::InvalidRequestException(const ::std::string& __ice_what) :
907#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
908 EhrException(__ice_what)
909#else
910 ::Ehr::EhrException(__ice_what)
911#endif
912{
913}
914
915Ehr::InvalidRequestException::~InvalidRequestException() throw()
916{
917}
918
919static const char* __Ehr__InvalidRequestException_name = "Ehr::InvalidRequestException";
920
921::std::string
922Ehr::InvalidRequestException::ice_name() const
923{
924 return __Ehr__InvalidRequestException_name;
925}
926
927::Ice::Exception*
928Ehr::InvalidRequestException::ice_clone() const
929{
930 return new InvalidRequestException(*this);
931}
932
933void
934Ehr::InvalidRequestException::ice_throw() const
935{
936 throw *this;
937}
938
939void
940Ehr::InvalidRequestException::__write(::IceInternal::BasicStream* __os) const
941{
942 __os->write(::std::string("::Ehr::InvalidRequestException"), false);
943 __os->startWriteSlice();
944 __os->endWriteSlice();
945#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
946 EhrException::__write(__os);
947#else
948 ::Ehr::EhrException::__write(__os);
949#endif
950}
951
952void
953Ehr::InvalidRequestException::__read(::IceInternal::BasicStream* __is, bool __rid)
954{
955 if(__rid)
956 {
957 ::std::string myId;
958 __is->read(myId, false);
959 }
960 __is->startReadSlice();
961 __is->endReadSlice();
962#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
963 EhrException::__read(__is, true);
964#else
965 ::Ehr::EhrException::__read(__is, true);
966#endif
967}
968
969void
970Ehr::InvalidRequestException::__write(const ::Ice::OutputStreamPtr& __outS) const
971{
972 __outS->writeString(::std::string("::Ehr::InvalidRequestException"));
973 __outS->startSlice();
974 __outS->endSlice();
975#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
976 EhrException::__write(__outS);
977#else
978 ::Ehr::EhrException::__write(__outS);
979#endif
980}
981
982void
983Ehr::InvalidRequestException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
984{
985 if(__rid)
986 {
987 __inS->readString();
988 }
989 __inS->startSlice();
990 __inS->endSlice();
991#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
992 EhrException::__read(__inS, true);
993#else
994 ::Ehr::EhrException::__read(__inS, true);
995#endif
996}
997
998struct __F__Ehr__InvalidRequestException : public ::IceInternal::UserExceptionFactory
999{
1000 virtual void
1001 createAndThrow()
1002 {
1003 throw ::Ehr::InvalidRequestException();
1004 }
1005};
1006
1007static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidRequestException__Ptr = new __F__Ehr__InvalidRequestException;
1008
1009const ::IceInternal::UserExceptionFactoryPtr&
1010Ehr::InvalidRequestException::ice_factory()
1011{
1012 return __F__Ehr__InvalidRequestException__Ptr;
1013}
1014
1015class __F__Ehr__InvalidRequestException__Init
1016{
1017public:
1018
1019 __F__Ehr__InvalidRequestException__Init()
1020 {
1021 ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidRequestException", ::Ehr::InvalidRequestException::ice_factory());
1022 }
1023
1024 ~__F__Ehr__InvalidRequestException__Init()
1025 {
1026 ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidRequestException");
1027 }
1028};
1029
1030static __F__Ehr__InvalidRequestException__Init __F__Ehr__InvalidRequestException__i;
1031
1032#ifdef __APPLE__
1033extern "C" { void __F__Ehr__InvalidRequestException__initializer() {} }
1034#endif
1035
1036Ehr::InvalidAccountException::InvalidAccountException(const ::std::string& __ice_what) :
1037#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1038 InvalidRequestException(__ice_what)
1039#else
1040 ::Ehr::InvalidRequestException(__ice_what)
1041#endif
1042{
1043}
1044
1045Ehr::InvalidAccountException::~InvalidAccountException() throw()
1046{
1047}
1048
1049static const char* __Ehr__InvalidAccountException_name = "Ehr::InvalidAccountException";
1050
1051::std::string
1052Ehr::InvalidAccountException::ice_name() const
1053{
1054 return __Ehr__InvalidAccountException_name;
1055}
1056
1057::Ice::Exception*
1058Ehr::InvalidAccountException::ice_clone() const
1059{
1060 return new InvalidAccountException(*this);
1061}
1062
1063void
1064Ehr::InvalidAccountException::ice_throw() const
1065{
1066 throw *this;
1067}
1068
1069void
1070Ehr::InvalidAccountException::__write(::IceInternal::BasicStream* __os) const
1071{
1072 __os->write(::std::string("::Ehr::InvalidAccountException"), false);
1073 __os->startWriteSlice();
1074 __os->endWriteSlice();
1075#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1076 InvalidRequestException::__write(__os);
1077#else
1078 ::Ehr::InvalidRequestException::__write(__os);
1079#endif
1080}
1081
1082void
1083Ehr::InvalidAccountException::__read(::IceInternal::BasicStream* __is, bool __rid)
1084{
1085 if(__rid)
1086 {
1087 ::std::string myId;
1088 __is->read(myId, false);
1089 }
1090 __is->startReadSlice();
1091 __is->endReadSlice();
1092#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1093 InvalidRequestException::__read(__is, true);
1094#else
1095 ::Ehr::InvalidRequestException::__read(__is, true);
1096#endif
1097}
1098
1099void
1100Ehr::InvalidAccountException::__write(const ::Ice::OutputStreamPtr& __outS) const
1101{
1102 __outS->writeString(::std::string("::Ehr::InvalidAccountException"));
1103 __outS->startSlice();
1104 __outS->endSlice();
1105#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1106 InvalidRequestException::__write(__outS);
1107#else
1108 ::Ehr::InvalidRequestException::__write(__outS);
1109#endif
1110}
1111
1112void
1113Ehr::InvalidAccountException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
1114{
1115 if(__rid)
1116 {
1117 __inS->readString();
1118 }
1119 __inS->startSlice();
1120 __inS->endSlice();
1121#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1122 InvalidRequestException::__read(__inS, true);
1123#else
1124 ::Ehr::InvalidRequestException::__read(__inS, true);
1125#endif
1126}
1127
1128struct __F__Ehr__InvalidAccountException : public ::IceInternal::UserExceptionFactory
1129{
1130 virtual void
1131 createAndThrow()
1132 {
1133 throw ::Ehr::InvalidAccountException();
1134 }
1135};
1136
1137static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidAccountException__Ptr = new __F__Ehr__InvalidAccountException;
1138
1139const ::IceInternal::UserExceptionFactoryPtr&
1140Ehr::InvalidAccountException::ice_factory()
1141{
1142 return __F__Ehr__InvalidAccountException__Ptr;
1143}
1144
1145class __F__Ehr__InvalidAccountException__Init
1146{
1147public:
1148
1149 __F__Ehr__InvalidAccountException__Init()
1150 {
1151 ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidAccountException", ::Ehr::InvalidAccountException::ice_factory());
1152 }
1153
1154 ~__F__Ehr__InvalidAccountException__Init()
1155 {
1156 ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidAccountException");
1157 }
1158};
1159
1160static __F__Ehr__InvalidAccountException__Init __F__Ehr__InvalidAccountException__i;
1161
1162#ifdef __APPLE__
1163extern "C" { void __F__Ehr__InvalidAccountException__initializer() {} }
1164#endif
1165
1166Ehr::SignatureException::SignatureException(const ::std::string& __ice_what) :
1167#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1168 EhrException(__ice_what)
1169#else
1170 ::Ehr::EhrException(__ice_what)
1171#endif
1172{
1173}
1174
1175Ehr::SignatureException::~SignatureException() throw()
1176{
1177}
1178
1179static const char* __Ehr__SignatureException_name = "Ehr::SignatureException";
1180
1181::std::string
1182Ehr::SignatureException::ice_name() const
1183{
1184 return __Ehr__SignatureException_name;
1185}
1186
1187::Ice::Exception*
1188Ehr::SignatureException::ice_clone() const
1189{
1190 return new SignatureException(*this);
1191}
1192
1193void
1194Ehr::SignatureException::ice_throw() const
1195{
1196 throw *this;
1197}
1198
1199void
1200Ehr::SignatureException::__write(::IceInternal::BasicStream* __os) const
1201{
1202 __os->write(::std::string("::Ehr::SignatureException"), false);
1203 __os->startWriteSlice();
1204 __os->endWriteSlice();
1205#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1206 EhrException::__write(__os);
1207#else
1208 ::Ehr::EhrException::__write(__os);
1209#endif
1210}
1211
1212void
1213Ehr::SignatureException::__read(::IceInternal::BasicStream* __is, bool __rid)
1214{
1215 if(__rid)
1216 {
1217 ::std::string myId;
1218 __is->read(myId, false);
1219 }
1220 __is->startReadSlice();
1221 __is->endReadSlice();
1222#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1223 EhrException::__read(__is, true);
1224#else
1225 ::Ehr::EhrException::__read(__is, true);
1226#endif
1227}
1228
1229void
1230Ehr::SignatureException::__write(const ::Ice::OutputStreamPtr& __outS) const
1231{
1232 __outS->writeString(::std::string("::Ehr::SignatureException"));
1233 __outS->startSlice();
1234 __outS->endSlice();
1235#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1236 EhrException::__write(__outS);
1237#else
1238 ::Ehr::EhrException::__write(__outS);
1239#endif
1240}
1241
1242void
1243Ehr::SignatureException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
1244{
1245 if(__rid)
1246 {
1247 __inS->readString();
1248 }
1249 __inS->startSlice();
1250 __inS->endSlice();
1251#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1252 EhrException::__read(__inS, true);
1253#else
1254 ::Ehr::EhrException::__read(__inS, true);
1255#endif
1256}
1257
1258struct __F__Ehr__SignatureException : public ::IceInternal::UserExceptionFactory
1259{
1260 virtual void
1261 createAndThrow()
1262 {
1263 throw ::Ehr::SignatureException();
1264 }
1265};
1266
1267static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__SignatureException__Ptr = new __F__Ehr__SignatureException;
1268
1269const ::IceInternal::UserExceptionFactoryPtr&
1270Ehr::SignatureException::ice_factory()
1271{
1272 return __F__Ehr__SignatureException__Ptr;
1273}
1274
1275class __F__Ehr__SignatureException__Init
1276{
1277public:
1278
1279 __F__Ehr__SignatureException__Init()
1280 {
1281 ::IceInternal::factoryTable->addExceptionFactory("::Ehr::SignatureException", ::Ehr::SignatureException::ice_factory());
1282 }
1283
1284 ~__F__Ehr__SignatureException__Init()
1285 {
1286 ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::SignatureException");
1287 }
1288};
1289
1290static __F__Ehr__SignatureException__Init __F__Ehr__SignatureException__i;
1291
1292#ifdef __APPLE__
1293extern "C" { void __F__Ehr__SignatureException__initializer() {} }
1294#endif
1295
1296Ehr::PermissionDeniedException::PermissionDeniedException(const ::std::string& __ice_what) :
1297#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1298 EhrException(__ice_what)
1299#else
1300 ::Ehr::EhrException(__ice_what)
1301#endif
1302{
1303}
1304
1305Ehr::PermissionDeniedException::~PermissionDeniedException() throw()
1306{
1307}
1308
1309static const char* __Ehr__PermissionDeniedException_name = "Ehr::PermissionDeniedException";
1310
1311::std::string
1312Ehr::PermissionDeniedException::ice_name() const
1313{
1314 return __Ehr__PermissionDeniedException_name;
1315}
1316
1317::Ice::Exception*
1318Ehr::PermissionDeniedException::ice_clone() const
1319{
1320 return new PermissionDeniedException(*this);
1321}
1322
1323void
1324Ehr::PermissionDeniedException::ice_throw() const
1325{
1326 throw *this;
1327}
1328
1329void
1330Ehr::PermissionDeniedException::__write(::IceInternal::BasicStream* __os) const
1331{
1332 __os->write(::std::string("::Ehr::PermissionDeniedException"), false);
1333 __os->startWriteSlice();
1334 __os->endWriteSlice();
1335#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1336 EhrException::__write(__os);
1337#else
1338 ::Ehr::EhrException::__write(__os);
1339#endif
1340}
1341
1342void
1343Ehr::PermissionDeniedException::__read(::IceInternal::BasicStream* __is, bool __rid)
1344{
1345 if(__rid)
1346 {
1347 ::std::string myId;
1348 __is->read(myId, false);
1349 }
1350 __is->startReadSlice();
1351 __is->endReadSlice();
1352#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1353 EhrException::__read(__is, true);
1354#else
1355 ::Ehr::EhrException::__read(__is, true);
1356#endif
1357}
1358
1359void
1360Ehr::PermissionDeniedException::__write(const ::Ice::OutputStreamPtr& __outS) const
1361{
1362 __outS->writeString(::std::string("::Ehr::PermissionDeniedException"));
1363 __outS->startSlice();
1364 __outS->endSlice();
1365#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1366 EhrException::__write(__outS);
1367#else
1368 ::Ehr::EhrException::__write(__outS);
1369#endif
1370}
1371
1372void
1373Ehr::PermissionDeniedException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
1374{
1375 if(__rid)
1376 {
1377 __inS->readString();
1378 }
1379 __inS->startSlice();
1380 __inS->endSlice();
1381#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1382 EhrException::__read(__inS, true);
1383#else
1384 ::Ehr::EhrException::__read(__inS, true);
1385#endif
1386}
1387
1388struct __F__Ehr__PermissionDeniedException : public ::IceInternal::UserExceptionFactory
1389{
1390 virtual void
1391 createAndThrow()
1392 {
1393 throw ::Ehr::PermissionDeniedException();
1394 }
1395};
1396
1397static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__PermissionDeniedException__Ptr = new __F__Ehr__PermissionDeniedException;
1398
1399const ::IceInternal::UserExceptionFactoryPtr&
1400Ehr::PermissionDeniedException::ice_factory()
1401{
1402 return __F__Ehr__PermissionDeniedException__Ptr;
1403}
1404
1405class __F__Ehr__PermissionDeniedException__Init
1406{
1407public:
1408
1409 __F__Ehr__PermissionDeniedException__Init()
1410 {
1411 ::IceInternal::factoryTable->addExceptionFactory("::Ehr::PermissionDeniedException", ::Ehr::PermissionDeniedException::ice_factory());
1412 }
1413
1414 ~__F__Ehr__PermissionDeniedException__Init()
1415 {
1416 ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::PermissionDeniedException");
1417 }
1418};
1419
1420static __F__Ehr__PermissionDeniedException__Init __F__Ehr__PermissionDeniedException__i;
1421
1422#ifdef __APPLE__
1423extern "C" { void __F__Ehr__PermissionDeniedException__initializer() {} }
1424#endif
1425
1426bool
1427Ehr::AccountIdentifier::operator==(const AccountIdentifier& __rhs) const
1428{
1429 if(this == &__rhs)
1430 {
1431 return true;
1432 }
1433 if(user != __rhs.user)
1434 {
1435 return false;
1436 }
1437 if(provider != __rhs.provider)
1438 {
1439 return false;
1440 }
1441 return true;
1442}
1443
1444bool
1445Ehr::AccountIdentifier::operator<(const AccountIdentifier& __rhs) const
1446{
1447 if(this == &__rhs)
1448 {
1449 return false;
1450 }
1451 if(user < __rhs.user)
1452 {
1453 return true;
1454 }
1455 else if(__rhs.user < user)
1456 {
1457 return false;
1458 }
1459 if(provider < __rhs.provider)
1460 {
1461 return true;
1462 }
1463 else if(__rhs.provider < provider)
1464 {
1465 return false;
1466 }
1467 return false;
1468}
1469
1470void
1471Ehr::AccountIdentifier::__write(::IceInternal::BasicStream* __os) const
1472{
1473 __os->write(user);
1474 __os->write(provider);
1475}
1476
1477void
1478Ehr::AccountIdentifier::__read(::IceInternal::BasicStream* __is)
1479{
1480 __is->read(user);
1481 __is->read(provider);
1482}
1483
1484void
1485Ehr::AccountIdentifier::ice_write(const ::Ice::OutputStreamPtr& __outS) const
1486{
1487 __outS->writeString(user);
1488 __outS->writeString(provider);
1489}
1490
1491void
1492Ehr::AccountIdentifier::ice_read(const ::Ice::InputStreamPtr& __inS)
1493{
1494 user = __inS->readString();
1495 provider = __inS->readString();
1496}
1497
1498void
1499Ehr::ice_writeAccountIdentifier(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccountIdentifier& __v)
1500{
1501 __v.ice_write(__outS);
1502}
1503
1504void
1505Ehr::ice_readAccountIdentifier(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccountIdentifier& __v)
1506{
1507 __v.ice_read(__inS);
1508}
1509
1510void
1511Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::DocumentType v)
1512{
1513 __os->write(static_cast< ::Ice::Byte>(v), 3);
1514}
1515
1516void
1517Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentType& v)
1518{
1519 ::Ice::Byte val;
1520 __is->read(val, 3);
1521 v = static_cast< ::Ehr::DocumentType>(val);
1522}
1523
1524void
1525Ehr::ice_writeDocumentType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::DocumentType v)
1526{
1527 if(static_cast<int>(v) >= 3)
1528 {
1529 throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
1530 }
1531 __outS->writeByte(static_cast< ::Ice::Byte>(v));
1532}
1533
1534void
1535Ehr::ice_readDocumentType(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentType& v)
1536{
1537 ::Ice::Byte val = __inS->readByte();
1538 if(val > 3)
1539 {
1540 throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
1541 }
1542 v = static_cast< ::Ehr::DocumentType>(val);
1543}
1544
1545bool
1546Ehr::Signature::operator==(const Signature& __rhs) const
1547{
1548 if(this == &__rhs)
1549 {
1550 return true;
1551 }
1552 if(data != __rhs.data)
1553 {
1554 return false;
1555 }
1556 return true;
1557}
1558
1559bool
1560Ehr::Signature::operator<(const Signature& __rhs) const
1561{
1562 if(this == &__rhs)
1563 {
1564 return false;
1565 }
1566 if(data < __rhs.data)
1567 {
1568 return true;
1569 }
1570 else if(__rhs.data < data)
1571 {
1572 return false;
1573 }
1574 return false;
1575}
1576
1577void
1578Ehr::Signature::__write(::IceInternal::BasicStream* __os) const
1579{
1580 if(data.size() == 0)
1581 {
1582 __os->writeSize(0);
1583 }
1584 else
1585 {
1586 __os->write(&data[0], &data[0] + data.size());
1587 }
1588}
1589
1590void
1591Ehr::Signature::__read(::IceInternal::BasicStream* __is)
1592{
1593 ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___data;
1594 __is->read(___data);
1595 ::std::vector< ::Ice::Byte>(___data.first, ___data.second).swap(data);
1596}
1597
1598void
1599Ehr::Signature::ice_write(const ::Ice::OutputStreamPtr& __outS) const
1600{
1601 __outS->writeByteSeq(data);
1602}
1603
1604void
1605Ehr::Signature::ice_read(const ::Ice::InputStreamPtr& __inS)
1606{
1607 data = __inS->readByteSeq();
1608}
1609
1610void
1611Ehr::ice_writeSignature(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Signature& __v)
1612{
1613 __v.ice_write(__outS);
1614}
1615
1616void
1617Ehr::ice_readSignature(const ::Ice::InputStreamPtr& __inS, ::Ehr::Signature& __v)
1618{
1619 __v.ice_read(__inS);
1620}
1621
1622bool
1623Ehr::Timestamp::operator==(const Timestamp& __rhs) const
1624{
1625 if(this == &__rhs)
1626 {
1627 return true;
1628 }
1629 if(msecs != __rhs.msecs)
1630 {
1631 return false;
1632 }
1633 return true;
1634}
1635
1636bool
1637Ehr::Timestamp::operator<(const Timestamp& __rhs) const
1638{
1639 if(this == &__rhs)
1640 {
1641 return false;
1642 }
1643 if(msecs < __rhs.msecs)
1644 {
1645 return true;
1646 }
1647 else if(__rhs.msecs < msecs)
1648 {
1649 return false;
1650 }
1651 return false;
1652}
1653
1654void
1655Ehr::Timestamp::__write(::IceInternal::BasicStream* __os) const
1656{
1657 __os->write(msecs);
1658}
1659
1660void
1661Ehr::Timestamp::__read(::IceInternal::BasicStream* __is)
1662{
1663 __is->read(msecs);
1664}
1665
1666void
1667Ehr::Timestamp::ice_write(const ::Ice::OutputStreamPtr& __outS) const
1668{
1669 __outS->writeLong(msecs);
1670}
1671
1672void
1673Ehr::Timestamp::ice_read(const ::Ice::InputStreamPtr& __inS)
1674{
1675 msecs = __inS->readLong();
1676}
1677
1678void
1679Ehr::ice_writeTimestamp(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Timestamp& __v)
1680{
1681 __v.ice_write(__outS);
1682}
1683
1684void
1685Ehr::ice_readTimestamp(const ::Ice::InputStreamPtr& __inS, ::Ehr::Timestamp& __v)
1686{
1687 __v.ice_read(__inS);
1688}
1689
1690bool
1691Ehr::Date::operator==(const Date& __rhs) const
1692{
1693 if(this == &__rhs)
1694 {
1695 return true;
1696 }
1697 if(day != __rhs.day)
1698 {
1699 return false;
1700 }
1701 if(month != __rhs.month)
1702 {
1703 return false;
1704 }
1705 if(year != __rhs.year)
1706 {
1707 return false;
1708 }
1709 return true;
1710}
1711
1712bool
1713Ehr::Date::operator<(const Date& __rhs) const
1714{
1715 if(this == &__rhs)
1716 {
1717 return false;
1718 }
1719 if(day < __rhs.day)
1720 {
1721 return true;
1722 }
1723 else if(__rhs.day < day)
1724 {
1725 return false;
1726 }
1727 if(month < __rhs.month)
1728 {
1729 return true;
1730 }
1731 else if(__rhs.month < month)
1732 {
1733 return false;
1734 }
1735 if(year < __rhs.year)
1736 {
1737 return true;
1738 }
1739 else if(__rhs.year < year)
1740 {
1741 return false;
1742 }
1743 return false;
1744}
1745
1746void
1747Ehr::Date::__write(::IceInternal::BasicStream* __os) const
1748{
1749 __os->write(day);
1750 __os->write(month);
1751 __os->write(year);
1752}
1753
1754void
1755Ehr::Date::__read(::IceInternal::BasicStream* __is)
1756{
1757 __is->read(day);
1758 __is->read(month);
1759 __is->read(year);
1760}
1761
1762void
1763Ehr::Date::ice_write(const ::Ice::OutputStreamPtr& __outS) const
1764{
1765 __outS->writeByte(day);
1766 __outS->writeByte(month);
1767 __outS->writeShort(year);
1768}
1769
1770void
1771Ehr::Date::ice_read(const ::Ice::InputStreamPtr& __inS)
1772{
1773 day = __inS->readByte();
1774 month = __inS->readByte();
1775 year = __inS->readShort();
1776}
1777
1778void
1779Ehr::ice_writeDate(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Date& __v)
1780{
1781 __v.ice_write(__outS);
1782}
1783
1784void
1785Ehr::ice_readDate(const ::Ice::InputStreamPtr& __inS, ::Ehr::Date& __v)
1786{
1787 __v.ice_read(__inS);
1788}
1789
1790void
1791Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::AccessType v)
1792{
1793 __os->write(static_cast< ::Ice::Byte>(v), 2);
1794}
1795
1796void
1797Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::AccessType& v)
1798{
1799 ::Ice::Byte val;
1800 __is->read(val, 2);
1801 v = static_cast< ::Ehr::AccessType>(val);
1802}
1803
1804void
1805Ehr::ice_writeAccessType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::AccessType v)
1806{
1807 if(static_cast<int>(v) >= 2)
1808 {
1809 throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
1810 }
1811 __outS->writeByte(static_cast< ::Ice::Byte>(v));
1812}
1813
1814void
1815Ehr::ice_readAccessType(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessType& v)
1816{
1817 ::Ice::Byte val = __inS->readByte();
1818 if(val > 2)
1819 {
1820 throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
1821 }
1822 v = static_cast< ::Ehr::AccessType>(val);
1823}
1824
1825bool
1826Ehr::EncryptedDocument::operator==(const EncryptedDocument& __rhs) const
1827{
1828 if(this == &__rhs)
1829 {
1830 return true;
1831 }
1832 if(encryptedKey != __rhs.encryptedKey)
1833 {
1834 return false;
1835 }
1836 if(initialVector != __rhs.initialVector)
1837 {
1838 return false;
1839 }
1840 if(encryptedData != __rhs.encryptedData)
1841 {
1842 return false;
1843 }
1844 return true;
1845}
1846
1847bool
1848Ehr::EncryptedDocument::operator<(const EncryptedDocument& __rhs) const
1849{
1850 if(this == &__rhs)
1851 {
1852 return false;
1853 }
1854 if(encryptedKey < __rhs.encryptedKey)
1855 {
1856 return true;
1857 }
1858 else if(__rhs.encryptedKey < encryptedKey)
1859 {
1860 return false;
1861 }
1862 if(initialVector < __rhs.initialVector)
1863 {
1864 return true;
1865 }
1866 else if(__rhs.initialVector < initialVector)
1867 {
1868 return false;
1869 }
1870 if(encryptedData < __rhs.encryptedData)
1871 {
1872 return true;
1873 }
1874 else if(__rhs.encryptedData < encryptedData)
1875 {
1876 return false;
1877 }
1878 return false;
1879}
1880
1881void
1882Ehr::EncryptedDocument::__write(::IceInternal::BasicStream* __os) const
1883{
1884 if(encryptedKey.size() == 0)
1885 {
1886 __os->writeSize(0);
1887 }
1888 else
1889 {
1890 __os->write(&encryptedKey[0], &encryptedKey[0] + encryptedKey.size());
1891 }
1892 if(initialVector.size() == 0)
1893 {
1894 __os->writeSize(0);
1895 }
1896 else
1897 {
1898 __os->write(&initialVector[0], &initialVector[0] + initialVector.size());
1899 }
1900 if(encryptedData.size() == 0)
1901 {
1902 __os->writeSize(0);
1903 }
1904 else
1905 {
1906 __os->write(&encryptedData[0], &encryptedData[0] + encryptedData.size());
1907 }
1908}
1909
1910void
1911Ehr::EncryptedDocument::__read(::IceInternal::BasicStream* __is)
1912{
1913 ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedKey;
1914 __is->read(___encryptedKey);
1915 ::std::vector< ::Ice::Byte>(___encryptedKey.first, ___encryptedKey.second).swap(encryptedKey);
1916 ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___initialVector;
1917 __is->read(___initialVector);
1918 ::std::vector< ::Ice::Byte>(___initialVector.first, ___initialVector.second).swap(initialVector);
1919 ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedData;
1920 __is->read(___encryptedData);
1921 ::std::vector< ::Ice::Byte>(___encryptedData.first, ___encryptedData.second).swap(encryptedData);
1922}
1923
1924void
1925Ehr::EncryptedDocument::ice_write(const ::Ice::OutputStreamPtr& __outS) const
1926{
1927 __outS->writeByteSeq(encryptedKey);
1928 __outS->writeByteSeq(initialVector);
1929 __outS->writeByteSeq(encryptedData);
1930}
1931
1932void
1933Ehr::EncryptedDocument::ice_read(const ::Ice::InputStreamPtr& __inS)
1934{
1935 encryptedKey = __inS->readByteSeq();
1936 initialVector = __inS->readByteSeq();
1937 encryptedData = __inS->readByteSeq();
1938}
1939
1940void
1941Ehr::ice_writeEncryptedDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::EncryptedDocument& __v)
1942{
1943 __v.ice_write(__outS);
1944}
1945
1946void
1947Ehr::ice_readEncryptedDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::EncryptedDocument& __v)
1948{
1949 __v.ice_read(__inS);
1950}
1951
1952bool
1953Ehr::DocumentListItem::operator==(const DocumentListItem& __rhs) const
1954{
1955 if(this == &__rhs)
1956 {
1957 return true;
1958 }
1959 if(id != __rhs.id)
1960 {
1961 return false;
1962 }
1963 if(created != __rhs.created)
1964 {
1965 return false;
1966 }
1967 if(document != __rhs.document)
1968 {
1969 return false;
1970 }
1971 return true;
1972}
1973
1974bool
1975Ehr::DocumentListItem::operator<(const DocumentListItem& __rhs) const
1976{
1977 if(this == &__rhs)
1978 {
1979 return false;
1980 }
1981 if(id < __rhs.id)
1982 {
1983 return true;
1984 }
1985 else if(__rhs.id < id)
1986 {
1987 return false;
1988 }
1989 if(created < __rhs.created)
1990 {
1991 return true;
1992 }
1993 else if(__rhs.created < created)
1994 {
1995 return false;
1996 }
1997 if(document < __rhs.document)
1998 {
1999 return true;
2000 }
2001 else if(__rhs.document < document)
2002 {
2003 return false;
2004 }
2005 return false;
2006}
2007
2008void
2009Ehr::DocumentListItem::__write(::IceInternal::BasicStream* __os) const
2010{
2011 __os->write(id);
2012 created.__write(__os);
2013 document.__write(__os);
2014}
2015
2016void
2017Ehr::DocumentListItem::__read(::IceInternal::BasicStream* __is)
2018{
2019 __is->read(id);
2020 created.__read(__is);
2021 document.__read(__is);
2022}
2023
2024void
2025Ehr::DocumentListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
2026{
2027 __outS->writeLong(id);
2028 ::Ehr::ice_writeTimestamp(__outS, created);
2029 ::Ehr::ice_writeEncryptedDocument(__outS, document);
2030}
2031
2032void
2033Ehr::DocumentListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
2034{
2035 id = __inS->readLong();
2036 ::Ehr::ice_readTimestamp(__inS, created);
2037 ::Ehr::ice_readEncryptedDocument(__inS, document);
2038}
2039
2040void
2041Ehr::ice_writeDocumentListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentListItem& __v)
2042{
2043 __v.ice_write(__outS);
2044}
2045
2046void
2047Ehr::ice_readDocumentListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentListItem& __v)
2048{
2049 __v.ice_read(__inS);
2050}
2051
2052void
2053Ehr::__writeDocumentList(::IceInternal::BasicStream* __os, const ::Ehr::DocumentListItem* begin, const ::Ehr::DocumentListItem* end)
2054{
2055 ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
2056 __os->writeSize(size);
2057 for(int i = 0; i < size; ++i)
2058 {
2059 begin[i].__write(__os);
2060 }
2061}
2062
2063void
2064Ehr::__readDocumentList(::IceInternal::BasicStream* __is, ::Ehr::DocumentList& v)
2065{
2066 ::Ice::Int sz;
2067 __is->readSize(sz);
2068 __is->startSeq(sz, 19);
2069 v.resize(sz);
2070 for(int i = 0; i < sz; ++i)
2071 {
2072 v[i].__read(__is);
2073 __is->checkSeq();
2074 __is->endElement();
2075 }
2076 __is->endSeq(sz);
2077}
2078
2079void
2080Ehr::ice_writeDocumentList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentList& v)
2081{
2082 __outS->writeSize(::Ice::Int(v.size()));
2083 ::Ehr::DocumentList::const_iterator p;
2084 for(p = v.begin(); p != v.end(); ++p)
2085 {
2086 ::Ehr::ice_writeDocumentListItem(__outS, (*p));
2087 }
2088}
2089
2090void
2091Ehr::ice_readDocumentList(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentList& v)
2092{
2093 ::Ice::Int sz = __inS->readSize();
2094 v.resize(sz);
2095 for(int i = 0; i < sz; ++i)
2096 {
2097 ::Ehr::ice_readDocumentListItem(__inS, v[i]);
2098 }
2099}
2100
2101bool
2102Ehr::AccessControlListItem::operator==(const AccessControlListItem& __rhs) const
2103{
2104 if(this == &__rhs)
2105 {
2106 return true;
2107 }
2108 if(id != __rhs.id)
2109 {
2110 return false;
2111 }
2112 if(account != __rhs.account)
2113 {
2114 return false;
2115 }
2116 if(access != __rhs.access)
2117 {
2118 return false;
2119 }
2120 return true;
2121}
2122
2123bool
2124Ehr::AccessControlListItem::operator<(const AccessControlListItem& __rhs) const
2125{
2126 if(this == &__rhs)
2127 {
2128 return false;
2129 }
2130 if(id < __rhs.id)
2131 {
2132 return true;
2133 }
2134 else if(__rhs.id < id)
2135 {
2136 return false;
2137 }
2138 if(account < __rhs.account)
2139 {
2140 return true;
2141 }
2142 else if(__rhs.account < account)
2143 {
2144 return false;
2145 }
2146 if(access < __rhs.access)
2147 {
2148 return true;
2149 }
2150 else if(__rhs.access < access)
2151 {
2152 return false;
2153 }
2154 return false;
2155}
2156
2157void
2158Ehr::AccessControlListItem::__write(::IceInternal::BasicStream* __os) const
2159{
2160 __os->write(id);
2161 account.__write(__os);
2162 ::Ehr::__write(__os, access);
2163}
2164
2165void
2166Ehr::AccessControlListItem::__read(::IceInternal::BasicStream* __is)
2167{
2168 __is->read(id);
2169 account.__read(__is);
2170 ::Ehr::__read(__is, access);
2171}
2172
2173void
2174Ehr::AccessControlListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
2175{
2176 __outS->writeLong(id);
2177 ::Ehr::ice_writeAccountIdentifier(__outS, account);
2178 ::Ehr::ice_writeAccessType(__outS, access);
2179}
2180
2181void
2182Ehr::AccessControlListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
2183{
2184 id = __inS->readLong();
2185 ::Ehr::ice_readAccountIdentifier(__inS, account);
2186 ::Ehr::ice_readAccessType(__inS, access);
2187}
2188
2189void
2190Ehr::ice_writeAccessControlListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlListItem& __v)
2191{
2192 __v.ice_write(__outS);
2193}
2194
2195void
2196Ehr::ice_readAccessControlListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlListItem& __v)
2197{
2198 __v.ice_read(__inS);
2199}
2200
2201void
2202Ehr::__writeAccessControlList(::IceInternal::BasicStream* __os, const ::Ehr::AccessControlListItem* begin, const ::Ehr::AccessControlListItem* end)
2203{
2204 ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
2205 __os->writeSize(size);
2206 for(int i = 0; i < size; ++i)
2207 {
2208 begin[i].__write(__os);
2209 }
2210}
2211
2212void
2213Ehr::__readAccessControlList(::IceInternal::BasicStream* __is, ::Ehr::AccessControlList& v)
2214{
2215 ::Ice::Int sz;
2216 __is->readSize(sz);
2217 __is->startSeq(sz, 11);
2218 v.resize(sz);
2219 for(int i = 0; i < sz; ++i)
2220 {
2221 v[i].__read(__is);
2222 __is->checkSeq();
2223 __is->endElement();
2224 }
2225 __is->endSeq(sz);
2226}
2227
2228void
2229Ehr::ice_writeAccessControlList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlList& v)
2230{
2231 __outS->writeSize(::Ice::Int(v.size()));
2232 ::Ehr::AccessControlList::const_iterator p;
2233 for(p = v.begin(); p != v.end(); ++p)
2234 {
2235 ::Ehr::ice_writeAccessControlListItem(__outS, (*p));
2236 }
2237}
2238
2239void
2240Ehr::ice_readAccessControlList(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlList& v)
2241{
2242 ::Ice::Int sz = __inS->readSize();
2243 v.resize(sz);
2244 for(int i = 0; i < sz; ++i)
2245 {
2246 ::Ehr::ice_readAccessControlListItem(__inS, v[i]);
2247 }
2248}
2249
2250bool
2251Ehr::Permissions::operator==(const Permissions& __rhs) const
2252{
2253 if(this == &__rhs)
2254 {
2255 return true;
2256 }
2257 if(defaultAccess != __rhs.defaultAccess)
2258 {
2259 return false;
2260 }
2261 if(acl != __rhs.acl)
2262 {
2263 return false;
2264 }
2265 return true;
2266}
2267
2268bool
2269Ehr::Permissions::operator<(const Permissions& __rhs) const
2270{
2271 if(this == &__rhs)
2272 {
2273 return false;
2274 }
2275 if(defaultAccess < __rhs.defaultAccess)
2276 {
2277 return true;
2278 }
2279 else if(__rhs.defaultAccess < defaultAccess)
2280 {
2281 return false;
2282 }
2283 if(acl < __rhs.acl)
2284 {
2285 return true;
2286 }
2287 else if(__rhs.acl < acl)
2288 {
2289 return false;
2290 }
2291 return false;
2292}
2293
2294void
2295Ehr::Permissions::__write(::IceInternal::BasicStream* __os) const
2296{
2297 ::Ehr::__write(__os, defaultAccess);
2298 if(acl.size() == 0)
2299 {
2300 __os->writeSize(0);
2301 }
2302 else
2303 {
2304 ::Ehr::__writeAccessControlList(__os, &acl[0], &acl[0] + acl.size());
2305 }
2306}
2307
2308void
2309Ehr::Permissions::__read(::IceInternal::BasicStream* __is)
2310{
2311 ::Ehr::__read(__is, defaultAccess);
2312 ::Ehr::__readAccessControlList(__is, acl);
2313}
2314
2315void
2316Ehr::Permissions::ice_write(const ::Ice::OutputStreamPtr& __outS) const
2317{
2318 ::Ehr::ice_writeAccessType(__outS, defaultAccess);
2319 ::Ehr::ice_writeAccessControlList(__outS, acl);
2320}
2321
2322void
2323Ehr::Permissions::ice_read(const ::Ice::InputStreamPtr& __inS)
2324{
2325 ::Ehr::ice_readAccessType(__inS, defaultAccess);
2326 ::Ehr::ice_readAccessControlList(__inS, acl);
2327}
2328
2329void
2330Ehr::ice_writePermissions(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Permissions& __v)
2331{
2332 __v.ice_write(__outS);
2333}
2334
2335void
2336Ehr::ice_readPermissions(const ::Ice::InputStreamPtr& __inS, ::Ehr::Permissions& __v)
2337{
2338 __v.ice_read(__inS);
2339}
2340
2341const ::std::string&
2342IceProxy::Ehr::Document::ice_staticId()
2343{
2344 return ::Ehr::Document::ice_staticId();
2345}
2346
2347::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2348IceProxy::Ehr::Document::__createDelegateM()
2349{
2350 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Document);
2351}
2352
2353::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2354IceProxy::Ehr::Document::__createDelegateD()
2355{
2356 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Document);
2357}
2358
2359::IceProxy::Ice::Object*
2360IceProxy::Ehr::Document::__newInstance() const
2361{
2362 return new Document;
2363}
2364
2365const ::std::string&
2366IceProxy::Ehr::Prescription::ice_staticId()
2367{
2368 return ::Ehr::Prescription::ice_staticId();
2369}
2370
2371::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2372IceProxy::Ehr::Prescription::__createDelegateM()
2373{
2374 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Prescription);
2375}
2376
2377::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2378IceProxy::Ehr::Prescription::__createDelegateD()
2379{
2380 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Prescription);
2381}
2382
2383::IceProxy::Ice::Object*
2384IceProxy::Ehr::Prescription::__newInstance() const
2385{
2386 return new Prescription;
2387}
2388
2389const ::std::string&
2390IceProxy::Ehr::ConsumedPrescription::ice_staticId()
2391{
2392 return ::Ehr::ConsumedPrescription::ice_staticId();
2393}
2394
2395::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2396IceProxy::Ehr::ConsumedPrescription::__createDelegateM()
2397{
2398 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumedPrescription);
2399}
2400
2401::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2402IceProxy::Ehr::ConsumedPrescription::__createDelegateD()
2403{
2404 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumedPrescription);
2405}
2406
2407::IceProxy::Ice::Object*
2408IceProxy::Ehr::ConsumedPrescription::__newInstance() const
2409{
2410 return new ConsumedPrescription;
2411}
2412
2413const ::std::string&
2414IceProxy::Ehr::Request::ice_staticId()
2415{
2416 return ::Ehr::Request::ice_staticId();
2417}
2418
2419::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2420IceProxy::Ehr::Request::__createDelegateM()
2421{
2422 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Request);
2423}
2424
2425::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2426IceProxy::Ehr::Request::__createDelegateD()
2427{
2428 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Request);
2429}
2430
2431::IceProxy::Ice::Object*
2432IceProxy::Ehr::Request::__newInstance() const
2433{
2434 return new Request;
2435}
2436
2437const ::std::string&
2438IceProxy::Ehr::ThirdPartyRequest::ice_staticId()
2439{
2440 return ::Ehr::ThirdPartyRequest::ice_staticId();
2441}
2442
2443::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2444IceProxy::Ehr::ThirdPartyRequest::__createDelegateM()
2445{
2446 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ThirdPartyRequest);
2447}
2448
2449::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2450IceProxy::Ehr::ThirdPartyRequest::__createDelegateD()
2451{
2452 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ThirdPartyRequest);
2453}
2454
2455::IceProxy::Ice::Object*
2456IceProxy::Ehr::ThirdPartyRequest::__newInstance() const
2457{
2458 return new ThirdPartyRequest;
2459}
2460
2461const ::std::string&
2462IceProxy::Ehr::CreatePrescriptionRequest::ice_staticId()
2463{
2464 return ::Ehr::CreatePrescriptionRequest::ice_staticId();
2465}
2466
2467::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2468IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateM()
2469{
2470 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePrescriptionRequest);
2471}
2472
2473::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2474IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateD()
2475{
2476 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePrescriptionRequest);
2477}
2478
2479::IceProxy::Ice::Object*
2480IceProxy::Ehr::CreatePrescriptionRequest::__newInstance() const
2481{
2482 return new CreatePrescriptionRequest;
2483}
2484
2485const ::std::string&
2486IceProxy::Ehr::ConsumePrescriptionRequest::ice_staticId()
2487{
2488 return ::Ehr::ConsumePrescriptionRequest::ice_staticId();
2489}
2490
2491::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2492IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateM()
2493{
2494 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumePrescriptionRequest);
2495}
2496
2497::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2498IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateD()
2499{
2500 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumePrescriptionRequest);
2501}
2502
2503::IceProxy::Ice::Object*
2504IceProxy::Ehr::ConsumePrescriptionRequest::__newInstance() const
2505{
2506 return new ConsumePrescriptionRequest;
2507}
2508
2509const ::std::string&
2510IceProxy::Ehr::ListDocumentsRequest::ice_staticId()
2511{
2512 return ::Ehr::ListDocumentsRequest::ice_staticId();
2513}
2514
2515::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2516IceProxy::Ehr::ListDocumentsRequest::__createDelegateM()
2517{
2518 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListDocumentsRequest);
2519}
2520
2521::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2522IceProxy::Ehr::ListDocumentsRequest::__createDelegateD()
2523{
2524 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListDocumentsRequest);
2525}
2526
2527::IceProxy::Ice::Object*
2528IceProxy::Ehr::ListDocumentsRequest::__newInstance() const
2529{
2530 return new ListDocumentsRequest;
2531}
2532
2533const ::std::string&
2534IceProxy::Ehr::FindDocumentsRequest::ice_staticId()
2535{
2536 return ::Ehr::FindDocumentsRequest::ice_staticId();
2537}
2538
2539::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2540IceProxy::Ehr::FindDocumentsRequest::__createDelegateM()
2541{
2542 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::FindDocumentsRequest);
2543}
2544
2545::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2546IceProxy::Ehr::FindDocumentsRequest::__createDelegateD()
2547{
2548 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::FindDocumentsRequest);
2549}
2550
2551::IceProxy::Ice::Object*
2552IceProxy::Ehr::FindDocumentsRequest::__newInstance() const
2553{
2554 return new FindDocumentsRequest;
2555}
2556
2557const ::std::string&
2558IceProxy::Ehr::CreatePermissionRequest::ice_staticId()
2559{
2560 return ::Ehr::CreatePermissionRequest::ice_staticId();
2561}
2562
2563::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2564IceProxy::Ehr::CreatePermissionRequest::__createDelegateM()
2565{
2566 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePermissionRequest);
2567}
2568
2569::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2570IceProxy::Ehr::CreatePermissionRequest::__createDelegateD()
2571{
2572 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePermissionRequest);
2573}
2574
2575::IceProxy::Ice::Object*
2576IceProxy::Ehr::CreatePermissionRequest::__newInstance() const
2577{
2578 return new CreatePermissionRequest;
2579}
2580
2581const ::std::string&
2582IceProxy::Ehr::SetDefaultAccessRequest::ice_staticId()
2583{
2584 return ::Ehr::SetDefaultAccessRequest::ice_staticId();
2585}
2586
2587::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2588IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateM()
2589{
2590 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::SetDefaultAccessRequest);
2591}
2592
2593::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2594IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateD()
2595{
2596 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::SetDefaultAccessRequest);
2597}
2598
2599::IceProxy::Ice::Object*
2600IceProxy::Ehr::SetDefaultAccessRequest::__newInstance() const
2601{
2602 return new SetDefaultAccessRequest;
2603}
2604
2605const ::std::string&
2606IceProxy::Ehr::ListPermissionsRequest::ice_staticId()
2607{
2608 return ::Ehr::ListPermissionsRequest::ice_staticId();
2609}
2610
2611::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2612IceProxy::Ehr::ListPermissionsRequest::__createDelegateM()
2613{
2614 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListPermissionsRequest);
2615}
2616
2617::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2618IceProxy::Ehr::ListPermissionsRequest::__createDelegateD()
2619{
2620 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListPermissionsRequest);
2621}
2622
2623::IceProxy::Ice::Object*
2624IceProxy::Ehr::ListPermissionsRequest::__newInstance() const
2625{
2626 return new ListPermissionsRequest;
2627}
2628
2629const ::std::string&
2630IceProxy::Ehr::RemovePermissionRequest::ice_staticId()
2631{
2632 return ::Ehr::RemovePermissionRequest::ice_staticId();
2633}
2634
2635::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2636IceProxy::Ehr::RemovePermissionRequest::__createDelegateM()
2637{
2638 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::RemovePermissionRequest);
2639}
2640
2641::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2642IceProxy::Ehr::RemovePermissionRequest::__createDelegateD()
2643{
2644 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::RemovePermissionRequest);
2645}
2646
2647::IceProxy::Ice::Object*
2648IceProxy::Ehr::RemovePermissionRequest::__newInstance() const
2649{
2650 return new RemovePermissionRequest;
2651}
2652
2653void
2654IceProxy::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
2655{
2656 int __cnt = 0;
2657 while(true)
2658 {
2659 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2660 try
2661 {
2662#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2663 IceUtil::DummyBCC dummy;
2664#endif
2665 __checkTwowayOnly(__Ehr__Provider__createPrescription_name);
2666 __delBase = __getDelegate(false);
2667 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2668 __del->createPrescription(request, requestorSignature, ownerSignature, __ctx);
2669 return;
2670 }
2671 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2672 {
2673 __handleExceptionWrapper(__delBase, __ex, 0);
2674 }
2675 catch(const ::Ice::LocalException& __ex)
2676 {
2677 __handleException(__delBase, __ex, 0, __cnt);
2678 }
2679 }
2680}
2681
2682void
2683IceProxy::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
2684{
2685 int __cnt = 0;
2686 while(true)
2687 {
2688 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2689 try
2690 {
2691#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2692 IceUtil::DummyBCC dummy;
2693#endif
2694 __checkTwowayOnly(__Ehr__Provider__consumePrescription_name);
2695 __delBase = __getDelegate(false);
2696 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2697 __del->consumePrescription(request, requestorSignature, ownerSignature, __ctx);
2698 return;
2699 }
2700 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2701 {
2702 __handleExceptionWrapper(__delBase, __ex, 0);
2703 }
2704 catch(const ::Ice::LocalException& __ex)
2705 {
2706 __handleException(__delBase, __ex, 0, __cnt);
2707 }
2708 }
2709}
2710
2711::Ehr::DocumentList
2712IceProxy::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
2713{
2714 int __cnt = 0;
2715 while(true)
2716 {
2717 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2718 try
2719 {
2720#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2721 IceUtil::DummyBCC dummy;
2722#endif
2723 __checkTwowayOnly(__Ehr__Provider__listDocuments_name);
2724 __delBase = __getDelegate(false);
2725 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2726 return __del->listDocuments(request, requestorSignature, ownerSignature, __ctx);
2727 }
2728 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2729 {
2730 __handleExceptionWrapper(__delBase, __ex, 0);
2731 }
2732 catch(const ::Ice::LocalException& __ex)
2733 {
2734 __handleException(__delBase, __ex, 0, __cnt);
2735 }
2736 }
2737}
2738
2739::Ehr::DocumentList
2740IceProxy::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
2741{
2742 int __cnt = 0;
2743 while(true)
2744 {
2745 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2746 try
2747 {
2748#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2749 IceUtil::DummyBCC dummy;
2750#endif
2751 __checkTwowayOnly(__Ehr__Provider__findDocuments_name);
2752 __delBase = __getDelegate(false);
2753 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2754 return __del->findDocuments(request, requestorSignature, ownerSignature, __ctx);
2755 }
2756 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2757 {
2758 __handleExceptionWrapper(__delBase, __ex, 0);
2759 }
2760 catch(const ::Ice::LocalException& __ex)
2761 {
2762 __handleException(__delBase, __ex, 0, __cnt);
2763 }
2764 }
2765}
2766
2767void
2768IceProxy::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
2769{
2770 int __cnt = 0;
2771 while(true)
2772 {
2773 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2774 try
2775 {
2776#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2777 IceUtil::DummyBCC dummy;
2778#endif
2779 __checkTwowayOnly(__Ehr__Provider__setDefaultAccess_name);
2780 __delBase = __getDelegate(false);
2781 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2782 __del->setDefaultAccess(request, requestorSignature, __ctx);
2783 return;
2784 }
2785 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2786 {
2787 __handleExceptionWrapper(__delBase, __ex, 0);
2788 }
2789 catch(const ::Ice::LocalException& __ex)
2790 {
2791 __handleException(__delBase, __ex, 0, __cnt);
2792 }
2793 }
2794}
2795
2796void
2797IceProxy::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
2798{
2799 int __cnt = 0;
2800 while(true)
2801 {
2802 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2803 try
2804 {
2805#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2806 IceUtil::DummyBCC dummy;
2807#endif
2808 __checkTwowayOnly(__Ehr__Provider__createPermission_name);
2809 __delBase = __getDelegate(false);
2810 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2811 __del->createPermission(request, requestorSignature, __ctx);
2812 return;
2813 }
2814 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2815 {
2816 __handleExceptionWrapper(__delBase, __ex, 0);
2817 }
2818 catch(const ::Ice::LocalException& __ex)
2819 {
2820 __handleException(__delBase, __ex, 0, __cnt);
2821 }
2822 }
2823}
2824
2825::Ehr::Permissions
2826IceProxy::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
2827{
2828 int __cnt = 0;
2829 while(true)
2830 {
2831 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2832 try
2833 {
2834#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2835 IceUtil::DummyBCC dummy;
2836#endif
2837 __checkTwowayOnly(__Ehr__Provider__listPermissions_name);
2838 __delBase = __getDelegate(false);
2839 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2840 return __del->listPermissions(request, requestorSignature, __ctx);
2841 }
2842 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2843 {
2844 __handleExceptionWrapper(__delBase, __ex, 0);
2845 }
2846 catch(const ::Ice::LocalException& __ex)
2847 {
2848 __handleException(__delBase, __ex, 0, __cnt);
2849 }
2850 }
2851}
2852
2853void
2854IceProxy::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
2855{
2856 int __cnt = 0;
2857 while(true)
2858 {
2859 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
2860 try
2861 {
2862#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
2863 IceUtil::DummyBCC dummy;
2864#endif
2865 __checkTwowayOnly(__Ehr__Provider__removePermission_name);
2866 __delBase = __getDelegate(false);
2867 ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
2868 __del->removePermission(request, requestorSignature, __ctx);
2869 return;
2870 }
2871 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
2872 {
2873 __handleExceptionWrapper(__delBase, __ex, 0);
2874 }
2875 catch(const ::Ice::LocalException& __ex)
2876 {
2877 __handleException(__delBase, __ex, 0, __cnt);
2878 }
2879 }
2880}
2881
2882const ::std::string&
2883IceProxy::Ehr::Provider::ice_staticId()
2884{
2885 return ::Ehr::Provider::ice_staticId();
2886}
2887
2888::IceInternal::Handle< ::IceDelegateM::Ice::Object>
2889IceProxy::Ehr::Provider::__createDelegateM()
2890{
2891 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Provider);
2892}
2893
2894::IceInternal::Handle< ::IceDelegateD::Ice::Object>
2895IceProxy::Ehr::Provider::__createDelegateD()
2896{
2897 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Provider);
2898}
2899
2900::IceProxy::Ice::Object*
2901IceProxy::Ehr::Provider::__newInstance() const
2902{
2903 return new Provider;
2904}
2905
2906void
2907IceDelegateM::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
2908{
2909 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
2910 try
2911 {
2912 ::IceInternal::BasicStream* __os = __og.os();
2913 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
2914 requestorSignature.__write(__os);
2915 ownerSignature.__write(__os);
2916 __os->writePendingObjects();
2917 }
2918 catch(const ::Ice::LocalException& __ex)
2919 {
2920 __og.abort(__ex);
2921 }
2922 bool __ok = __og.invoke();
2923 try
2924 {
2925 if(!__ok)
2926 {
2927 try
2928 {
2929 __og.throwUserException();
2930 }
2931 catch(const ::Ehr::EhrException&)
2932 {
2933 throw;
2934 }
2935 catch(const ::Ice::UserException& __ex)
2936 {
2937 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
2938 throw __uue;
2939 }
2940 }
2941 __og.is()->skipEmptyEncaps();
2942 }
2943 catch(const ::Ice::LocalException& __ex)
2944 {
2945 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
2946 }
2947}
2948
2949void
2950IceDelegateM::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
2951{
2952 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
2953 try
2954 {
2955 ::IceInternal::BasicStream* __os = __og.os();
2956 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
2957 requestorSignature.__write(__os);
2958 ownerSignature.__write(__os);
2959 __os->writePendingObjects();
2960 }
2961 catch(const ::Ice::LocalException& __ex)
2962 {
2963 __og.abort(__ex);
2964 }
2965 bool __ok = __og.invoke();
2966 try
2967 {
2968 if(!__ok)
2969 {
2970 try
2971 {
2972 __og.throwUserException();
2973 }
2974 catch(const ::Ehr::EhrException&)
2975 {
2976 throw;
2977 }
2978 catch(const ::Ice::UserException& __ex)
2979 {
2980 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
2981 throw __uue;
2982 }
2983 }
2984 __og.is()->skipEmptyEncaps();
2985 }
2986 catch(const ::Ice::LocalException& __ex)
2987 {
2988 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
2989 }
2990}
2991
2992::Ehr::DocumentList
2993IceDelegateM::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
2994{
2995 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
2996 try
2997 {
2998 ::IceInternal::BasicStream* __os = __og.os();
2999 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3000 requestorSignature.__write(__os);
3001 ownerSignature.__write(__os);
3002 __os->writePendingObjects();
3003 }
3004 catch(const ::Ice::LocalException& __ex)
3005 {
3006 __og.abort(__ex);
3007 }
3008 bool __ok = __og.invoke();
3009 ::Ehr::DocumentList __ret;
3010 try
3011 {
3012 if(!__ok)
3013 {
3014 try
3015 {
3016 __og.throwUserException();
3017 }
3018 catch(const ::Ehr::EhrException&)
3019 {
3020 throw;
3021 }
3022 catch(const ::Ice::UserException& __ex)
3023 {
3024 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3025 throw __uue;
3026 }
3027 }
3028 ::IceInternal::BasicStream* __is = __og.is();
3029 __is->startReadEncaps();
3030 ::Ehr::__readDocumentList(__is, __ret);
3031 __is->endReadEncaps();
3032 return __ret;
3033 }
3034 catch(const ::Ice::LocalException& __ex)
3035 {
3036 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3037 }
3038}
3039
3040::Ehr::DocumentList
3041IceDelegateM::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
3042{
3043 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
3044 try
3045 {
3046 ::IceInternal::BasicStream* __os = __og.os();
3047 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3048 requestorSignature.__write(__os);
3049 ownerSignature.__write(__os);
3050 __os->writePendingObjects();
3051 }
3052 catch(const ::Ice::LocalException& __ex)
3053 {
3054 __og.abort(__ex);
3055 }
3056 bool __ok = __og.invoke();
3057 ::Ehr::DocumentList __ret;
3058 try
3059 {
3060 if(!__ok)
3061 {
3062 try
3063 {
3064 __og.throwUserException();
3065 }
3066 catch(const ::Ehr::EhrException&)
3067 {
3068 throw;
3069 }
3070 catch(const ::Ice::UserException& __ex)
3071 {
3072 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3073 throw __uue;
3074 }
3075 }
3076 ::IceInternal::BasicStream* __is = __og.is();
3077 __is->startReadEncaps();
3078 ::Ehr::__readDocumentList(__is, __ret);
3079 __is->endReadEncaps();
3080 return __ret;
3081 }
3082 catch(const ::Ice::LocalException& __ex)
3083 {
3084 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3085 }
3086}
3087
3088void
3089IceDelegateM::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3090{
3091 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
3092 try
3093 {
3094 ::IceInternal::BasicStream* __os = __og.os();
3095 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3096 requestorSignature.__write(__os);
3097 __os->writePendingObjects();
3098 }
3099 catch(const ::Ice::LocalException& __ex)
3100 {
3101 __og.abort(__ex);
3102 }
3103 bool __ok = __og.invoke();
3104 try
3105 {
3106 if(!__ok)
3107 {
3108 try
3109 {
3110 __og.throwUserException();
3111 }
3112 catch(const ::Ehr::EhrException&)
3113 {
3114 throw;
3115 }
3116 catch(const ::Ice::UserException& __ex)
3117 {
3118 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3119 throw __uue;
3120 }
3121 }
3122 __og.is()->skipEmptyEncaps();
3123 }
3124 catch(const ::Ice::LocalException& __ex)
3125 {
3126 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3127 }
3128}
3129
3130void
3131IceDelegateM::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3132{
3133 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
3134 try
3135 {
3136 ::IceInternal::BasicStream* __os = __og.os();
3137 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3138 requestorSignature.__write(__os);
3139 __os->writePendingObjects();
3140 }
3141 catch(const ::Ice::LocalException& __ex)
3142 {
3143 __og.abort(__ex);
3144 }
3145 bool __ok = __og.invoke();
3146 try
3147 {
3148 if(!__ok)
3149 {
3150 try
3151 {
3152 __og.throwUserException();
3153 }
3154 catch(const ::Ehr::EhrException&)
3155 {
3156 throw;
3157 }
3158 catch(const ::Ice::UserException& __ex)
3159 {
3160 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3161 throw __uue;
3162 }
3163 }
3164 __og.is()->skipEmptyEncaps();
3165 }
3166 catch(const ::Ice::LocalException& __ex)
3167 {
3168 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3169 }
3170}
3171
3172::Ehr::Permissions
3173IceDelegateM::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3174{
3175 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
3176 try
3177 {
3178 ::IceInternal::BasicStream* __os = __og.os();
3179 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3180 requestorSignature.__write(__os);
3181 __os->writePendingObjects();
3182 }
3183 catch(const ::Ice::LocalException& __ex)
3184 {
3185 __og.abort(__ex);
3186 }
3187 bool __ok = __og.invoke();
3188 ::Ehr::Permissions __ret;
3189 try
3190 {
3191 if(!__ok)
3192 {
3193 try
3194 {
3195 __og.throwUserException();
3196 }
3197 catch(const ::Ehr::EhrException&)
3198 {
3199 throw;
3200 }
3201 catch(const ::Ice::UserException& __ex)
3202 {
3203 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3204 throw __uue;
3205 }
3206 }
3207 ::IceInternal::BasicStream* __is = __og.is();
3208 __is->startReadEncaps();
3209 __ret.__read(__is);
3210 __is->endReadEncaps();
3211 return __ret;
3212 }
3213 catch(const ::Ice::LocalException& __ex)
3214 {
3215 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3216 }
3217}
3218
3219void
3220IceDelegateM::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3221{
3222 ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
3223 try
3224 {
3225 ::IceInternal::BasicStream* __os = __og.os();
3226 __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
3227 requestorSignature.__write(__os);
3228 __os->writePendingObjects();
3229 }
3230 catch(const ::Ice::LocalException& __ex)
3231 {
3232 __og.abort(__ex);
3233 }
3234 bool __ok = __og.invoke();
3235 try
3236 {
3237 if(!__ok)
3238 {
3239 try
3240 {
3241 __og.throwUserException();
3242 }
3243 catch(const ::Ehr::EhrException&)
3244 {
3245 throw;
3246 }
3247 catch(const ::Ice::UserException& __ex)
3248 {
3249 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
3250 throw __uue;
3251 }
3252 }
3253 __og.is()->skipEmptyEncaps();
3254 }
3255 catch(const ::Ice::LocalException& __ex)
3256 {
3257 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
3258 }
3259}
3260
3261void
3262IceDelegateD::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
3263{
3264 class _DirectI : public ::IceInternal::Direct
3265 {
3266 public:
3267
3268 _DirectI(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) :
3269 ::IceInternal::Direct(__current),
3270 _m_request(request),
3271 _m_requestorSignature(requestorSignature),
3272 _m_ownerSignature(ownerSignature)
3273 {
3274 }
3275
3276 virtual ::Ice::DispatchStatus
3277 run(::Ice::Object* object)
3278 {
3279 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3280 if(!servant)
3281 {
3282 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3283 }
3284 try
3285 {
3286 servant->createPrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
3287 return ::Ice::DispatchOK;
3288 }
3289 catch(const ::Ice::UserException& __ex)
3290 {
3291 setUserException(__ex);
3292 return ::Ice::DispatchUserException;
3293 }
3294 }
3295
3296 private:
3297
3298 const ::Ehr::CreatePrescriptionRequestPtr& _m_request;
3299 const ::Ehr::Signature& _m_requestorSignature;
3300 const ::Ehr::Signature& _m_ownerSignature;
3301 };
3302
3303 ::Ice::Current __current;
3304 __initCurrent(__current, __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
3305 try
3306 {
3307 _DirectI __direct(request, requestorSignature, ownerSignature, __current);
3308 try
3309 {
3310 __direct.servant()->__collocDispatch(__direct);
3311 }
3312 catch(...)
3313 {
3314 __direct.destroy();
3315 throw;
3316 }
3317 __direct.destroy();
3318 }
3319 catch(const ::Ehr::EhrException&)
3320 {
3321 throw;
3322 }
3323 catch(const ::Ice::SystemException&)
3324 {
3325 throw;
3326 }
3327 catch(const ::IceInternal::LocalExceptionWrapper&)
3328 {
3329 throw;
3330 }
3331 catch(const ::std::exception& __ex)
3332 {
3333 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3334 }
3335 catch(...)
3336 {
3337 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3338 }
3339}
3340
3341void
3342IceDelegateD::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
3343{
3344 class _DirectI : public ::IceInternal::Direct
3345 {
3346 public:
3347
3348 _DirectI(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) :
3349 ::IceInternal::Direct(__current),
3350 _m_request(request),
3351 _m_requestorSignature(requestorSignature),
3352 _m_ownerSignature(ownerSignature)
3353 {
3354 }
3355
3356 virtual ::Ice::DispatchStatus
3357 run(::Ice::Object* object)
3358 {
3359 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3360 if(!servant)
3361 {
3362 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3363 }
3364 try
3365 {
3366 servant->consumePrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
3367 return ::Ice::DispatchOK;
3368 }
3369 catch(const ::Ice::UserException& __ex)
3370 {
3371 setUserException(__ex);
3372 return ::Ice::DispatchUserException;
3373 }
3374 }
3375
3376 private:
3377
3378 const ::Ehr::ConsumePrescriptionRequestPtr& _m_request;
3379 const ::Ehr::Signature& _m_requestorSignature;
3380 const ::Ehr::Signature& _m_ownerSignature;
3381 };
3382
3383 ::Ice::Current __current;
3384 __initCurrent(__current, __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
3385 try
3386 {
3387 _DirectI __direct(request, requestorSignature, ownerSignature, __current);
3388 try
3389 {
3390 __direct.servant()->__collocDispatch(__direct);
3391 }
3392 catch(...)
3393 {
3394 __direct.destroy();
3395 throw;
3396 }
3397 __direct.destroy();
3398 }
3399 catch(const ::Ehr::EhrException&)
3400 {
3401 throw;
3402 }
3403 catch(const ::Ice::SystemException&)
3404 {
3405 throw;
3406 }
3407 catch(const ::IceInternal::LocalExceptionWrapper&)
3408 {
3409 throw;
3410 }
3411 catch(const ::std::exception& __ex)
3412 {
3413 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3414 }
3415 catch(...)
3416 {
3417 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3418 }
3419}
3420
3421::Ehr::DocumentList
3422IceDelegateD::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
3423{
3424 class _DirectI : public ::IceInternal::Direct
3425 {
3426 public:
3427
3428 _DirectI(::Ehr::DocumentList& __result, const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) :
3429 ::IceInternal::Direct(__current),
3430 _result(__result),
3431 _m_request(request),
3432 _m_requestorSignature(requestorSignature),
3433 _m_ownerSignature(ownerSignature)
3434 {
3435 }
3436
3437 virtual ::Ice::DispatchStatus
3438 run(::Ice::Object* object)
3439 {
3440 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3441 if(!servant)
3442 {
3443 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3444 }
3445 try
3446 {
3447 _result = servant->listDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
3448 return ::Ice::DispatchOK;
3449 }
3450 catch(const ::Ice::UserException& __ex)
3451 {
3452 setUserException(__ex);
3453 return ::Ice::DispatchUserException;
3454 }
3455 }
3456
3457 private:
3458
3459 ::Ehr::DocumentList& _result;
3460 const ::Ehr::ListDocumentsRequestPtr& _m_request;
3461 const ::Ehr::Signature& _m_requestorSignature;
3462 const ::Ehr::Signature& _m_ownerSignature;
3463 };
3464
3465 ::Ice::Current __current;
3466 __initCurrent(__current, __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
3467 ::Ehr::DocumentList __result;
3468 try
3469 {
3470 _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
3471 try
3472 {
3473 __direct.servant()->__collocDispatch(__direct);
3474 }
3475 catch(...)
3476 {
3477 __direct.destroy();
3478 throw;
3479 }
3480 __direct.destroy();
3481 }
3482 catch(const ::Ehr::EhrException&)
3483 {
3484 throw;
3485 }
3486 catch(const ::Ice::SystemException&)
3487 {
3488 throw;
3489 }
3490 catch(const ::IceInternal::LocalExceptionWrapper&)
3491 {
3492 throw;
3493 }
3494 catch(const ::std::exception& __ex)
3495 {
3496 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3497 }
3498 catch(...)
3499 {
3500 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3501 }
3502 return __result;
3503}
3504
3505::Ehr::DocumentList
3506IceDelegateD::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
3507{
3508 class _DirectI : public ::IceInternal::Direct
3509 {
3510 public:
3511
3512 _DirectI(::Ehr::DocumentList& __result, const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) :
3513 ::IceInternal::Direct(__current),
3514 _result(__result),
3515 _m_request(request),
3516 _m_requestorSignature(requestorSignature),
3517 _m_ownerSignature(ownerSignature)
3518 {
3519 }
3520
3521 virtual ::Ice::DispatchStatus
3522 run(::Ice::Object* object)
3523 {
3524 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3525 if(!servant)
3526 {
3527 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3528 }
3529 try
3530 {
3531 _result = servant->findDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
3532 return ::Ice::DispatchOK;
3533 }
3534 catch(const ::Ice::UserException& __ex)
3535 {
3536 setUserException(__ex);
3537 return ::Ice::DispatchUserException;
3538 }
3539 }
3540
3541 private:
3542
3543 ::Ehr::DocumentList& _result;
3544 const ::Ehr::FindDocumentsRequestPtr& _m_request;
3545 const ::Ehr::Signature& _m_requestorSignature;
3546 const ::Ehr::Signature& _m_ownerSignature;
3547 };
3548
3549 ::Ice::Current __current;
3550 __initCurrent(__current, __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
3551 ::Ehr::DocumentList __result;
3552 try
3553 {
3554 _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
3555 try
3556 {
3557 __direct.servant()->__collocDispatch(__direct);
3558 }
3559 catch(...)
3560 {
3561 __direct.destroy();
3562 throw;
3563 }
3564 __direct.destroy();
3565 }
3566 catch(const ::Ehr::EhrException&)
3567 {
3568 throw;
3569 }
3570 catch(const ::Ice::SystemException&)
3571 {
3572 throw;
3573 }
3574 catch(const ::IceInternal::LocalExceptionWrapper&)
3575 {
3576 throw;
3577 }
3578 catch(const ::std::exception& __ex)
3579 {
3580 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3581 }
3582 catch(...)
3583 {
3584 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3585 }
3586 return __result;
3587}
3588
3589void
3590IceDelegateD::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3591{
3592 class _DirectI : public ::IceInternal::Direct
3593 {
3594 public:
3595
3596 _DirectI(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) :
3597 ::IceInternal::Direct(__current),
3598 _m_request(request),
3599 _m_requestorSignature(requestorSignature)
3600 {
3601 }
3602
3603 virtual ::Ice::DispatchStatus
3604 run(::Ice::Object* object)
3605 {
3606 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3607 if(!servant)
3608 {
3609 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3610 }
3611 try
3612 {
3613 servant->setDefaultAccess(_m_request, _m_requestorSignature, _current);
3614 return ::Ice::DispatchOK;
3615 }
3616 catch(const ::Ice::UserException& __ex)
3617 {
3618 setUserException(__ex);
3619 return ::Ice::DispatchUserException;
3620 }
3621 }
3622
3623 private:
3624
3625 const ::Ehr::SetDefaultAccessRequestPtr& _m_request;
3626 const ::Ehr::Signature& _m_requestorSignature;
3627 };
3628
3629 ::Ice::Current __current;
3630 __initCurrent(__current, __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
3631 try
3632 {
3633 _DirectI __direct(request, requestorSignature, __current);
3634 try
3635 {
3636 __direct.servant()->__collocDispatch(__direct);
3637 }
3638 catch(...)
3639 {
3640 __direct.destroy();
3641 throw;
3642 }
3643 __direct.destroy();
3644 }
3645 catch(const ::Ehr::EhrException&)
3646 {
3647 throw;
3648 }
3649 catch(const ::Ice::SystemException&)
3650 {
3651 throw;
3652 }
3653 catch(const ::IceInternal::LocalExceptionWrapper&)
3654 {
3655 throw;
3656 }
3657 catch(const ::std::exception& __ex)
3658 {
3659 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3660 }
3661 catch(...)
3662 {
3663 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3664 }
3665}
3666
3667void
3668IceDelegateD::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3669{
3670 class _DirectI : public ::IceInternal::Direct
3671 {
3672 public:
3673
3674 _DirectI(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) :
3675 ::IceInternal::Direct(__current),
3676 _m_request(request),
3677 _m_requestorSignature(requestorSignature)
3678 {
3679 }
3680
3681 virtual ::Ice::DispatchStatus
3682 run(::Ice::Object* object)
3683 {
3684 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3685 if(!servant)
3686 {
3687 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3688 }
3689 try
3690 {
3691 servant->createPermission(_m_request, _m_requestorSignature, _current);
3692 return ::Ice::DispatchOK;
3693 }
3694 catch(const ::Ice::UserException& __ex)
3695 {
3696 setUserException(__ex);
3697 return ::Ice::DispatchUserException;
3698 }
3699 }
3700
3701 private:
3702
3703 const ::Ehr::CreatePermissionRequestPtr& _m_request;
3704 const ::Ehr::Signature& _m_requestorSignature;
3705 };
3706
3707 ::Ice::Current __current;
3708 __initCurrent(__current, __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
3709 try
3710 {
3711 _DirectI __direct(request, requestorSignature, __current);
3712 try
3713 {
3714 __direct.servant()->__collocDispatch(__direct);
3715 }
3716 catch(...)
3717 {
3718 __direct.destroy();
3719 throw;
3720 }
3721 __direct.destroy();
3722 }
3723 catch(const ::Ehr::EhrException&)
3724 {
3725 throw;
3726 }
3727 catch(const ::Ice::SystemException&)
3728 {
3729 throw;
3730 }
3731 catch(const ::IceInternal::LocalExceptionWrapper&)
3732 {
3733 throw;
3734 }
3735 catch(const ::std::exception& __ex)
3736 {
3737 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3738 }
3739 catch(...)
3740 {
3741 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3742 }
3743}
3744
3745::Ehr::Permissions
3746IceDelegateD::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3747{
3748 class _DirectI : public ::IceInternal::Direct
3749 {
3750 public:
3751
3752 _DirectI(::Ehr::Permissions& __result, const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) :
3753 ::IceInternal::Direct(__current),
3754 _result(__result),
3755 _m_request(request),
3756 _m_requestorSignature(requestorSignature)
3757 {
3758 }
3759
3760 virtual ::Ice::DispatchStatus
3761 run(::Ice::Object* object)
3762 {
3763 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3764 if(!servant)
3765 {
3766 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3767 }
3768 try
3769 {
3770 _result = servant->listPermissions(_m_request, _m_requestorSignature, _current);
3771 return ::Ice::DispatchOK;
3772 }
3773 catch(const ::Ice::UserException& __ex)
3774 {
3775 setUserException(__ex);
3776 return ::Ice::DispatchUserException;
3777 }
3778 }
3779
3780 private:
3781
3782 ::Ehr::Permissions& _result;
3783 const ::Ehr::ListPermissionsRequestPtr& _m_request;
3784 const ::Ehr::Signature& _m_requestorSignature;
3785 };
3786
3787 ::Ice::Current __current;
3788 __initCurrent(__current, __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
3789 ::Ehr::Permissions __result;
3790 try
3791 {
3792 _DirectI __direct(__result, request, requestorSignature, __current);
3793 try
3794 {
3795 __direct.servant()->__collocDispatch(__direct);
3796 }
3797 catch(...)
3798 {
3799 __direct.destroy();
3800 throw;
3801 }
3802 __direct.destroy();
3803 }
3804 catch(const ::Ehr::EhrException&)
3805 {
3806 throw;
3807 }
3808 catch(const ::Ice::SystemException&)
3809 {
3810 throw;
3811 }
3812 catch(const ::IceInternal::LocalExceptionWrapper&)
3813 {
3814 throw;
3815 }
3816 catch(const ::std::exception& __ex)
3817 {
3818 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3819 }
3820 catch(...)
3821 {
3822 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3823 }
3824 return __result;
3825}
3826
3827void
3828IceDelegateD::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
3829{
3830 class _DirectI : public ::IceInternal::Direct
3831 {
3832 public:
3833
3834 _DirectI(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) :
3835 ::IceInternal::Direct(__current),
3836 _m_request(request),
3837 _m_requestorSignature(requestorSignature)
3838 {
3839 }
3840
3841 virtual ::Ice::DispatchStatus
3842 run(::Ice::Object* object)
3843 {
3844 ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
3845 if(!servant)
3846 {
3847 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
3848 }
3849 try
3850 {
3851 servant->removePermission(_m_request, _m_requestorSignature, _current);
3852 return ::Ice::DispatchOK;
3853 }
3854 catch(const ::Ice::UserException& __ex)
3855 {
3856 setUserException(__ex);
3857 return ::Ice::DispatchUserException;
3858 }
3859 }
3860
3861 private:
3862
3863 const ::Ehr::RemovePermissionRequestPtr& _m_request;
3864 const ::Ehr::Signature& _m_requestorSignature;
3865 };
3866
3867 ::Ice::Current __current;
3868 __initCurrent(__current, __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
3869 try
3870 {
3871 _DirectI __direct(request, requestorSignature, __current);
3872 try
3873 {
3874 __direct.servant()->__collocDispatch(__direct);
3875 }
3876 catch(...)
3877 {
3878 __direct.destroy();
3879 throw;
3880 }
3881 __direct.destroy();
3882 }
3883 catch(const ::Ehr::EhrException&)
3884 {
3885 throw;
3886 }
3887 catch(const ::Ice::SystemException&)
3888 {
3889 throw;
3890 }
3891 catch(const ::IceInternal::LocalExceptionWrapper&)
3892 {
3893 throw;
3894 }
3895 catch(const ::std::exception& __ex)
3896 {
3897 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
3898 }
3899 catch(...)
3900 {
3901 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
3902 }
3903}
3904
3905Ehr::Document::Document(::Ehr::DocumentType __ice_type) :
3906 type(__ice_type)
3907{
3908}
3909
3910::Ice::ObjectPtr
3911Ehr::Document::ice_clone() const
3912{
3913 ::Ehr::DocumentPtr __p = new ::Ehr::Document(*this);
3914 return __p;
3915}
3916
3917static const ::std::string __Ehr__Document_ids[2] =
3918{
3919 "::Ehr::Document",
3920 "::Ice::Object"
3921};
3922
3923bool
3924Ehr::Document::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
3925{
3926 return ::std::binary_search(__Ehr__Document_ids, __Ehr__Document_ids + 2, _s);
3927}
3928
3929::std::vector< ::std::string>
3930Ehr::Document::ice_ids(const ::Ice::Current&) const
3931{
3932 return ::std::vector< ::std::string>(&__Ehr__Document_ids[0], &__Ehr__Document_ids[2]);
3933}
3934
3935const ::std::string&
3936Ehr::Document::ice_id(const ::Ice::Current&) const
3937{
3938 return __Ehr__Document_ids[0];
3939}
3940
3941const ::std::string&
3942Ehr::Document::ice_staticId()
3943{
3944 return __Ehr__Document_ids[0];
3945}
3946
3947void
3948Ehr::Document::__write(::IceInternal::BasicStream* __os) const
3949{
3950 __os->writeTypeId(ice_staticId());
3951 __os->startWriteSlice();
3952 ::Ehr::__write(__os, type);
3953 __os->endWriteSlice();
3954#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3955 Object::__write(__os);
3956#else
3957 ::Ice::Object::__write(__os);
3958#endif
3959}
3960
3961void
3962Ehr::Document::__read(::IceInternal::BasicStream* __is, bool __rid)
3963{
3964 if(__rid)
3965 {
3966 ::std::string myId;
3967 __is->readTypeId(myId);
3968 }
3969 __is->startReadSlice();
3970 ::Ehr::__read(__is, type);
3971 __is->endReadSlice();
3972#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3973 Object::__read(__is, true);
3974#else
3975 ::Ice::Object::__read(__is, true);
3976#endif
3977}
3978
3979void
3980Ehr::Document::__write(const ::Ice::OutputStreamPtr& __outS) const
3981{
3982 __outS->writeTypeId(ice_staticId());
3983 __outS->startSlice();
3984 ::Ehr::ice_writeDocumentType(__outS, type);
3985 __outS->endSlice();
3986#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3987 Object::__write(__outS);
3988#else
3989 ::Ice::Object::__write(__outS);
3990#endif
3991}
3992
3993void
3994Ehr::Document::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
3995{
3996 if(__rid)
3997 {
3998 __inS->readTypeId();
3999 }
4000 __inS->startSlice();
4001 ::Ehr::ice_readDocumentType(__inS, type);
4002 __inS->endSlice();
4003#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4004 Object::__read(__inS, true);
4005#else
4006 ::Ice::Object::__read(__inS, true);
4007#endif
4008}
4009
4010class __F__Ehr__Document : public ::Ice::ObjectFactory
4011{
4012public:
4013
4014 virtual ::Ice::ObjectPtr
4015 create(const ::std::string& type)
4016 {
4017 assert(type == ::Ehr::Document::ice_staticId());
4018 return new ::Ehr::Document;
4019 }
4020
4021 virtual void
4022 destroy()
4023 {
4024 }
4025};
4026
4027static ::Ice::ObjectFactoryPtr __F__Ehr__Document_Ptr = new __F__Ehr__Document;
4028
4029const ::Ice::ObjectFactoryPtr&
4030Ehr::Document::ice_factory()
4031{
4032 return __F__Ehr__Document_Ptr;
4033}
4034
4035class __F__Ehr__Document__Init
4036{
4037public:
4038
4039 __F__Ehr__Document__Init()
4040 {
4041 ::IceInternal::factoryTable->addObjectFactory(::Ehr::Document::ice_staticId(), ::Ehr::Document::ice_factory());
4042 }
4043
4044 ~__F__Ehr__Document__Init()
4045 {
4046 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Document::ice_staticId());
4047 }
4048};
4049
4050static __F__Ehr__Document__Init __F__Ehr__Document__i;
4051
4052#ifdef __APPLE__
4053extern "C" { void __F__Ehr__Document__initializer() {} }
4054#endif
4055
4056void
4057Ehr::__patch__DocumentPtr(void* __addr, ::Ice::ObjectPtr& v)
4058{
4059 ::Ehr::DocumentPtr* p = static_cast< ::Ehr::DocumentPtr*>(__addr);
4060 assert(p);
4061 *p = ::Ehr::DocumentPtr::dynamicCast(v);
4062 if(v && !*p)
4063 {
4064 IceInternal::Ex::throwUOE(::Ehr::Document::ice_staticId(), v->ice_id());
4065 }
4066}
4067
4068bool
4069Ehr::operator==(const ::Ehr::Document& l, const ::Ehr::Document& r)
4070{
4071 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
4072}
4073
4074bool
4075Ehr::operator<(const ::Ehr::Document& l, const ::Ehr::Document& r)
4076{
4077 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
4078}
4079
4080Ehr::Prescription::Prescription(::Ehr::DocumentType __ice_type, const ::std::string& __ice_originatorName, const ::std::string& __ice_originatorProfession, const ::std::string& __ice_originatorAddress, const ::Ehr::Date& __ice_creationDate, const ::std::string& __ice_consumerName, const ::Ehr::Date& __ice_consumerDateOfBirth, const ::std::string& __ice_drugDescription, const ::std::string& __ice_form, ::Ice::Int __ice_dosage, const ::std::string& __ice_measuringUnit, const ::Ehr::Date& __ice_validFrom, const ::Ehr::Date& __ice_expires) :
4081#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4082 Document(__ice_type)
4083#else
4084 ::Ehr::Document(__ice_type)
4085#endif
4086,
4087 originatorName(__ice_originatorName),
4088 originatorProfession(__ice_originatorProfession),
4089 originatorAddress(__ice_originatorAddress),
4090 creationDate(__ice_creationDate),
4091 consumerName(__ice_consumerName),
4092 consumerDateOfBirth(__ice_consumerDateOfBirth),
4093 drugDescription(__ice_drugDescription),
4094 form(__ice_form),
4095 dosage(__ice_dosage),
4096 measuringUnit(__ice_measuringUnit),
4097 validFrom(__ice_validFrom),
4098 expires(__ice_expires)
4099{
4100}
4101
4102::Ice::ObjectPtr
4103Ehr::Prescription::ice_clone() const
4104{
4105 ::Ehr::PrescriptionPtr __p = new ::Ehr::Prescription(*this);
4106 return __p;
4107}
4108
4109static const ::std::string __Ehr__Prescription_ids[3] =
4110{
4111 "::Ehr::Document",
4112 "::Ehr::Prescription",
4113 "::Ice::Object"
4114};
4115
4116bool
4117Ehr::Prescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
4118{
4119 return ::std::binary_search(__Ehr__Prescription_ids, __Ehr__Prescription_ids + 3, _s);
4120}
4121
4122::std::vector< ::std::string>
4123Ehr::Prescription::ice_ids(const ::Ice::Current&) const
4124{
4125 return ::std::vector< ::std::string>(&__Ehr__Prescription_ids[0], &__Ehr__Prescription_ids[3]);
4126}
4127
4128const ::std::string&
4129Ehr::Prescription::ice_id(const ::Ice::Current&) const
4130{
4131 return __Ehr__Prescription_ids[1];
4132}
4133
4134const ::std::string&
4135Ehr::Prescription::ice_staticId()
4136{
4137 return __Ehr__Prescription_ids[1];
4138}
4139
4140void
4141Ehr::Prescription::__write(::IceInternal::BasicStream* __os) const
4142{
4143 __os->writeTypeId(ice_staticId());
4144 __os->startWriteSlice();
4145 __os->write(originatorName);
4146 __os->write(originatorProfession);
4147 __os->write(originatorAddress);
4148 creationDate.__write(__os);
4149 __os->write(consumerName);
4150 consumerDateOfBirth.__write(__os);
4151 __os->write(drugDescription);
4152 __os->write(form);
4153 __os->write(dosage);
4154 __os->write(measuringUnit);
4155 validFrom.__write(__os);
4156 expires.__write(__os);
4157 __os->endWriteSlice();
4158#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4159 Document::__write(__os);
4160#else
4161 ::Ehr::Document::__write(__os);
4162#endif
4163}
4164
4165void
4166Ehr::Prescription::__read(::IceInternal::BasicStream* __is, bool __rid)
4167{
4168 if(__rid)
4169 {
4170 ::std::string myId;
4171 __is->readTypeId(myId);
4172 }
4173 __is->startReadSlice();
4174 __is->read(originatorName);
4175 __is->read(originatorProfession);
4176 __is->read(originatorAddress);
4177 creationDate.__read(__is);
4178 __is->read(consumerName);
4179 consumerDateOfBirth.__read(__is);
4180 __is->read(drugDescription);
4181 __is->read(form);
4182 __is->read(dosage);
4183 __is->read(measuringUnit);
4184 validFrom.__read(__is);
4185 expires.__read(__is);
4186 __is->endReadSlice();
4187#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4188 Document::__read(__is, true);
4189#else
4190 ::Ehr::Document::__read(__is, true);
4191#endif
4192}
4193
4194void
4195Ehr::Prescription::__write(const ::Ice::OutputStreamPtr& __outS) const
4196{
4197 __outS->writeTypeId(ice_staticId());
4198 __outS->startSlice();
4199 __outS->writeString(originatorName);
4200 __outS->writeString(originatorProfession);
4201 __outS->writeString(originatorAddress);
4202 ::Ehr::ice_writeDate(__outS, creationDate);
4203 __outS->writeString(consumerName);
4204 ::Ehr::ice_writeDate(__outS, consumerDateOfBirth);
4205 __outS->writeString(drugDescription);
4206 __outS->writeString(form);
4207 __outS->writeInt(dosage);
4208 __outS->writeString(measuringUnit);
4209 ::Ehr::ice_writeDate(__outS, validFrom);
4210 ::Ehr::ice_writeDate(__outS, expires);
4211 __outS->endSlice();
4212#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4213 Document::__write(__outS);
4214#else
4215 ::Ehr::Document::__write(__outS);
4216#endif
4217}
4218
4219void
4220Ehr::Prescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
4221{
4222 if(__rid)
4223 {
4224 __inS->readTypeId();
4225 }
4226 __inS->startSlice();
4227 originatorName = __inS->readString();
4228 originatorProfession = __inS->readString();
4229 originatorAddress = __inS->readString();
4230 ::Ehr::ice_readDate(__inS, creationDate);
4231 consumerName = __inS->readString();
4232 ::Ehr::ice_readDate(__inS, consumerDateOfBirth);
4233 drugDescription = __inS->readString();
4234 form = __inS->readString();
4235 dosage = __inS->readInt();
4236 measuringUnit = __inS->readString();
4237 ::Ehr::ice_readDate(__inS, validFrom);
4238 ::Ehr::ice_readDate(__inS, expires);
4239 __inS->endSlice();
4240#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4241 Document::__read(__inS, true);
4242#else
4243 ::Ehr::Document::__read(__inS, true);
4244#endif
4245}
4246
4247class __F__Ehr__Prescription : public ::Ice::ObjectFactory
4248{
4249public:
4250
4251 virtual ::Ice::ObjectPtr
4252 create(const ::std::string& type)
4253 {
4254 assert(type == ::Ehr::Prescription::ice_staticId());
4255 return new ::Ehr::Prescription;
4256 }
4257
4258 virtual void
4259 destroy()
4260 {
4261 }
4262};
4263
4264static ::Ice::ObjectFactoryPtr __F__Ehr__Prescription_Ptr = new __F__Ehr__Prescription;
4265
4266const ::Ice::ObjectFactoryPtr&
4267Ehr::Prescription::ice_factory()
4268{
4269 return __F__Ehr__Prescription_Ptr;
4270}
4271
4272class __F__Ehr__Prescription__Init
4273{
4274public:
4275
4276 __F__Ehr__Prescription__Init()
4277 {
4278 ::IceInternal::factoryTable->addObjectFactory(::Ehr::Prescription::ice_staticId(), ::Ehr::Prescription::ice_factory());
4279 }
4280
4281 ~__F__Ehr__Prescription__Init()
4282 {
4283 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Prescription::ice_staticId());
4284 }
4285};
4286
4287static __F__Ehr__Prescription__Init __F__Ehr__Prescription__i;
4288
4289#ifdef __APPLE__
4290extern "C" { void __F__Ehr__Prescription__initializer() {} }
4291#endif
4292
4293void
4294Ehr::__patch__PrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
4295{
4296 ::Ehr::PrescriptionPtr* p = static_cast< ::Ehr::PrescriptionPtr*>(__addr);
4297 assert(p);
4298 *p = ::Ehr::PrescriptionPtr::dynamicCast(v);
4299 if(v && !*p)
4300 {
4301 IceInternal::Ex::throwUOE(::Ehr::Prescription::ice_staticId(), v->ice_id());
4302 }
4303}
4304
4305bool
4306Ehr::operator==(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
4307{
4308 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
4309}
4310
4311bool
4312Ehr::operator<(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
4313{
4314 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
4315}
4316
4317Ehr::ConsumedPrescription::ConsumedPrescription(::Ehr::DocumentType __ice_type, const ::std::string& __ice_originatorName, const ::std::string& __ice_originatorProfession, const ::std::string& __ice_originatorAddress, const ::Ehr::Date& __ice_creationDate, const ::std::string& __ice_consumerName, const ::Ehr::Date& __ice_consumerDateOfBirth, const ::std::string& __ice_drugDescription, const ::std::string& __ice_form, ::Ice::Int __ice_dosage, const ::std::string& __ice_measuringUnit, const ::Ehr::Date& __ice_validFrom, const ::Ehr::Date& __ice_expires, const ::std::string& __ice_dispenserName, const ::std::string& __ice_dispenserProfession, const ::std::string& __ice_dispenserAddress, const ::Ehr::Date& __ice_dispensingDate) :
4318#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4319 Document(__ice_type)
4320#else
4321 ::Ehr::Document(__ice_type)
4322#endif
4323,
4324#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4325 Prescription(__ice_type, __ice_originatorName, __ice_originatorProfession, __ice_originatorAddress, __ice_creationDate, __ice_consumerName, __ice_consumerDateOfBirth, __ice_drugDescription, __ice_form, __ice_dosage, __ice_measuringUnit, __ice_validFrom, __ice_expires)
4326#else
4327 ::Ehr::Prescription(__ice_type, __ice_originatorName, __ice_originatorProfession, __ice_originatorAddress, __ice_creationDate, __ice_consumerName, __ice_consumerDateOfBirth, __ice_drugDescription, __ice_form, __ice_dosage, __ice_measuringUnit, __ice_validFrom, __ice_expires)
4328#endif
4329,
4330 dispenserName(__ice_dispenserName),
4331 dispenserProfession(__ice_dispenserProfession),
4332 dispenserAddress(__ice_dispenserAddress),
4333 dispensingDate(__ice_dispensingDate)
4334{
4335}
4336
4337::Ice::ObjectPtr
4338Ehr::ConsumedPrescription::ice_clone() const
4339{
4340 ::Ehr::ConsumedPrescriptionPtr __p = new ::Ehr::ConsumedPrescription(*this);
4341 return __p;
4342}
4343
4344static const ::std::string __Ehr__ConsumedPrescription_ids[4] =
4345{
4346 "::Ehr::ConsumedPrescription",
4347 "::Ehr::Document",
4348 "::Ehr::Prescription",
4349 "::Ice::Object"
4350};
4351
4352bool
4353Ehr::ConsumedPrescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
4354{
4355 return ::std::binary_search(__Ehr__ConsumedPrescription_ids, __Ehr__ConsumedPrescription_ids + 4, _s);
4356}
4357
4358::std::vector< ::std::string>
4359Ehr::ConsumedPrescription::ice_ids(const ::Ice::Current&) const
4360{
4361 return ::std::vector< ::std::string>(&__Ehr__ConsumedPrescription_ids[0], &__Ehr__ConsumedPrescription_ids[4]);
4362}
4363
4364const ::std::string&
4365Ehr::ConsumedPrescription::ice_id(const ::Ice::Current&) const
4366{
4367 return __Ehr__ConsumedPrescription_ids[0];
4368}
4369
4370const ::std::string&
4371Ehr::ConsumedPrescription::ice_staticId()
4372{
4373 return __Ehr__ConsumedPrescription_ids[0];
4374}
4375
4376void
4377Ehr::ConsumedPrescription::__write(::IceInternal::BasicStream* __os) const
4378{
4379 __os->writeTypeId(ice_staticId());
4380 __os->startWriteSlice();
4381 __os->write(dispenserName);
4382 __os->write(dispenserProfession);
4383 __os->write(dispenserAddress);
4384 dispensingDate.__write(__os);
4385 __os->endWriteSlice();
4386#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4387 Prescription::__write(__os);
4388#else
4389 ::Ehr::Prescription::__write(__os);
4390#endif
4391}
4392
4393void
4394Ehr::ConsumedPrescription::__read(::IceInternal::BasicStream* __is, bool __rid)
4395{
4396 if(__rid)
4397 {
4398 ::std::string myId;
4399 __is->readTypeId(myId);
4400 }
4401 __is->startReadSlice();
4402 __is->read(dispenserName);
4403 __is->read(dispenserProfession);
4404 __is->read(dispenserAddress);
4405 dispensingDate.__read(__is);
4406 __is->endReadSlice();
4407#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4408 Prescription::__read(__is, true);
4409#else
4410 ::Ehr::Prescription::__read(__is, true);
4411#endif
4412}
4413
4414void
4415Ehr::ConsumedPrescription::__write(const ::Ice::OutputStreamPtr& __outS) const
4416{
4417 __outS->writeTypeId(ice_staticId());
4418 __outS->startSlice();
4419 __outS->writeString(dispenserName);
4420 __outS->writeString(dispenserProfession);
4421 __outS->writeString(dispenserAddress);
4422 ::Ehr::ice_writeDate(__outS, dispensingDate);
4423 __outS->endSlice();
4424#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4425 Prescription::__write(__outS);
4426#else
4427 ::Ehr::Prescription::__write(__outS);
4428#endif
4429}
4430
4431void
4432Ehr::ConsumedPrescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
4433{
4434 if(__rid)
4435 {
4436 __inS->readTypeId();
4437 }
4438 __inS->startSlice();
4439 dispenserName = __inS->readString();
4440 dispenserProfession = __inS->readString();
4441 dispenserAddress = __inS->readString();
4442 ::Ehr::ice_readDate(__inS, dispensingDate);
4443 __inS->endSlice();
4444#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4445 Prescription::__read(__inS, true);
4446#else
4447 ::Ehr::Prescription::__read(__inS, true);
4448#endif
4449}
4450
4451class __F__Ehr__ConsumedPrescription : public ::Ice::ObjectFactory
4452{
4453public:
4454
4455 virtual ::Ice::ObjectPtr
4456 create(const ::std::string& type)
4457 {
4458 assert(type == ::Ehr::ConsumedPrescription::ice_staticId());
4459 return new ::Ehr::ConsumedPrescription;
4460 }
4461
4462 virtual void
4463 destroy()
4464 {
4465 }
4466};
4467
4468static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumedPrescription_Ptr = new __F__Ehr__ConsumedPrescription;
4469
4470const ::Ice::ObjectFactoryPtr&
4471Ehr::ConsumedPrescription::ice_factory()
4472{
4473 return __F__Ehr__ConsumedPrescription_Ptr;
4474}
4475
4476class __F__Ehr__ConsumedPrescription__Init
4477{
4478public:
4479
4480 __F__Ehr__ConsumedPrescription__Init()
4481 {
4482 ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumedPrescription::ice_staticId(), ::Ehr::ConsumedPrescription::ice_factory());
4483 }
4484
4485 ~__F__Ehr__ConsumedPrescription__Init()
4486 {
4487 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumedPrescription::ice_staticId());
4488 }
4489};
4490
4491static __F__Ehr__ConsumedPrescription__Init __F__Ehr__ConsumedPrescription__i;
4492
4493#ifdef __APPLE__
4494extern "C" { void __F__Ehr__ConsumedPrescription__initializer() {} }
4495#endif
4496
4497void
4498Ehr::__patch__ConsumedPrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
4499{
4500 ::Ehr::ConsumedPrescriptionPtr* p = static_cast< ::Ehr::ConsumedPrescriptionPtr*>(__addr);
4501 assert(p);
4502 *p = ::Ehr::ConsumedPrescriptionPtr::dynamicCast(v);
4503 if(v && !*p)
4504 {
4505 IceInternal::Ex::throwUOE(::Ehr::ConsumedPrescription::ice_staticId(), v->ice_id());
4506 }
4507}
4508
4509bool
4510Ehr::operator==(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
4511{
4512 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
4513}
4514
4515bool
4516Ehr::operator<(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
4517{
4518 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
4519}
4520
4521Ehr::Request::Request(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when) :
4522 requestor(__ice_requestor),
4523 when(__ice_when)
4524{
4525}
4526
4527::Ice::ObjectPtr
4528Ehr::Request::ice_clone() const
4529{
4530 ::Ehr::RequestPtr __p = new ::Ehr::Request(*this);
4531 return __p;
4532}
4533
4534static const ::std::string __Ehr__Request_ids[2] =
4535{
4536 "::Ehr::Request",
4537 "::Ice::Object"
4538};
4539
4540bool
4541Ehr::Request::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
4542{
4543 return ::std::binary_search(__Ehr__Request_ids, __Ehr__Request_ids + 2, _s);
4544}
4545
4546::std::vector< ::std::string>
4547Ehr::Request::ice_ids(const ::Ice::Current&) const
4548{
4549 return ::std::vector< ::std::string>(&__Ehr__Request_ids[0], &__Ehr__Request_ids[2]);
4550}
4551
4552const ::std::string&
4553Ehr::Request::ice_id(const ::Ice::Current&) const
4554{
4555 return __Ehr__Request_ids[0];
4556}
4557
4558const ::std::string&
4559Ehr::Request::ice_staticId()
4560{
4561 return __Ehr__Request_ids[0];
4562}
4563
4564void
4565Ehr::Request::__write(::IceInternal::BasicStream* __os) const
4566{
4567 __os->writeTypeId(ice_staticId());
4568 __os->startWriteSlice();
4569 requestor.__write(__os);
4570 when.__write(__os);
4571 __os->endWriteSlice();
4572#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4573 Object::__write(__os);
4574#else
4575 ::Ice::Object::__write(__os);
4576#endif
4577}
4578
4579void
4580Ehr::Request::__read(::IceInternal::BasicStream* __is, bool __rid)
4581{
4582 if(__rid)
4583 {
4584 ::std::string myId;
4585 __is->readTypeId(myId);
4586 }
4587 __is->startReadSlice();
4588 requestor.__read(__is);
4589 when.__read(__is);
4590 __is->endReadSlice();
4591#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4592 Object::__read(__is, true);
4593#else
4594 ::Ice::Object::__read(__is, true);
4595#endif
4596}
4597
4598void
4599Ehr::Request::__write(const ::Ice::OutputStreamPtr& __outS) const
4600{
4601 __outS->writeTypeId(ice_staticId());
4602 __outS->startSlice();
4603 ::Ehr::ice_writeAccountIdentifier(__outS, requestor);
4604 ::Ehr::ice_writeTimestamp(__outS, when);
4605 __outS->endSlice();
4606#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4607 Object::__write(__outS);
4608#else
4609 ::Ice::Object::__write(__outS);
4610#endif
4611}
4612
4613void
4614Ehr::Request::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
4615{
4616 if(__rid)
4617 {
4618 __inS->readTypeId();
4619 }
4620 __inS->startSlice();
4621 ::Ehr::ice_readAccountIdentifier(__inS, requestor);
4622 ::Ehr::ice_readTimestamp(__inS, when);
4623 __inS->endSlice();
4624#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4625 Object::__read(__inS, true);
4626#else
4627 ::Ice::Object::__read(__inS, true);
4628#endif
4629}
4630
4631class __F__Ehr__Request : public ::Ice::ObjectFactory
4632{
4633public:
4634
4635 virtual ::Ice::ObjectPtr
4636 create(const ::std::string& type)
4637 {
4638 assert(type == ::Ehr::Request::ice_staticId());
4639 return new ::Ehr::Request;
4640 }
4641
4642 virtual void
4643 destroy()
4644 {
4645 }
4646};
4647
4648static ::Ice::ObjectFactoryPtr __F__Ehr__Request_Ptr = new __F__Ehr__Request;
4649
4650const ::Ice::ObjectFactoryPtr&
4651Ehr::Request::ice_factory()
4652{
4653 return __F__Ehr__Request_Ptr;
4654}
4655
4656class __F__Ehr__Request__Init
4657{
4658public:
4659
4660 __F__Ehr__Request__Init()
4661 {
4662 ::IceInternal::factoryTable->addObjectFactory(::Ehr::Request::ice_staticId(), ::Ehr::Request::ice_factory());
4663 }
4664
4665 ~__F__Ehr__Request__Init()
4666 {
4667 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Request::ice_staticId());
4668 }
4669};
4670
4671static __F__Ehr__Request__Init __F__Ehr__Request__i;
4672
4673#ifdef __APPLE__
4674extern "C" { void __F__Ehr__Request__initializer() {} }
4675#endif
4676
4677void
4678Ehr::__patch__RequestPtr(void* __addr, ::Ice::ObjectPtr& v)
4679{
4680 ::Ehr::RequestPtr* p = static_cast< ::Ehr::RequestPtr*>(__addr);
4681 assert(p);
4682 *p = ::Ehr::RequestPtr::dynamicCast(v);
4683 if(v && !*p)
4684 {
4685 IceInternal::Ex::throwUOE(::Ehr::Request::ice_staticId(), v->ice_id());
4686 }
4687}
4688
4689bool
4690Ehr::operator==(const ::Ehr::Request& l, const ::Ehr::Request& r)
4691{
4692 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
4693}
4694
4695bool
4696Ehr::operator<(const ::Ehr::Request& l, const ::Ehr::Request& r)
4697{
4698 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
4699}
4700
4701Ehr::ThirdPartyRequest::ThirdPartyRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
4702#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4703 Request(__ice_requestor, __ice_when)
4704#else
4705 ::Ehr::Request(__ice_requestor, __ice_when)
4706#endif
4707,
4708 owner(__ice_owner)
4709{
4710}
4711
4712::Ice::ObjectPtr
4713Ehr::ThirdPartyRequest::ice_clone() const
4714{
4715 ::Ehr::ThirdPartyRequestPtr __p = new ::Ehr::ThirdPartyRequest(*this);
4716 return __p;
4717}
4718
4719static const ::std::string __Ehr__ThirdPartyRequest_ids[3] =
4720{
4721 "::Ehr::Request",
4722 "::Ehr::ThirdPartyRequest",
4723 "::Ice::Object"
4724};
4725
4726bool
4727Ehr::ThirdPartyRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
4728{
4729 return ::std::binary_search(__Ehr__ThirdPartyRequest_ids, __Ehr__ThirdPartyRequest_ids + 3, _s);
4730}
4731
4732::std::vector< ::std::string>
4733Ehr::ThirdPartyRequest::ice_ids(const ::Ice::Current&) const
4734{
4735 return ::std::vector< ::std::string>(&__Ehr__ThirdPartyRequest_ids[0], &__Ehr__ThirdPartyRequest_ids[3]);
4736}
4737
4738const ::std::string&
4739Ehr::ThirdPartyRequest::ice_id(const ::Ice::Current&) const
4740{
4741 return __Ehr__ThirdPartyRequest_ids[1];
4742}
4743
4744const ::std::string&
4745Ehr::ThirdPartyRequest::ice_staticId()
4746{
4747 return __Ehr__ThirdPartyRequest_ids[1];
4748}
4749
4750void
4751Ehr::ThirdPartyRequest::__write(::IceInternal::BasicStream* __os) const
4752{
4753 __os->writeTypeId(ice_staticId());
4754 __os->startWriteSlice();
4755 owner.__write(__os);
4756 __os->endWriteSlice();
4757#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4758 Request::__write(__os);
4759#else
4760 ::Ehr::Request::__write(__os);
4761#endif
4762}
4763
4764void
4765Ehr::ThirdPartyRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
4766{
4767 if(__rid)
4768 {
4769 ::std::string myId;
4770 __is->readTypeId(myId);
4771 }
4772 __is->startReadSlice();
4773 owner.__read(__is);
4774 __is->endReadSlice();
4775#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4776 Request::__read(__is, true);
4777#else
4778 ::Ehr::Request::__read(__is, true);
4779#endif
4780}
4781
4782void
4783Ehr::ThirdPartyRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
4784{
4785 __outS->writeTypeId(ice_staticId());
4786 __outS->startSlice();
4787 ::Ehr::ice_writeAccountIdentifier(__outS, owner);
4788 __outS->endSlice();
4789#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4790 Request::__write(__outS);
4791#else
4792 ::Ehr::Request::__write(__outS);
4793#endif
4794}
4795
4796void
4797Ehr::ThirdPartyRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
4798{
4799 if(__rid)
4800 {
4801 __inS->readTypeId();
4802 }
4803 __inS->startSlice();
4804 ::Ehr::ice_readAccountIdentifier(__inS, owner);
4805 __inS->endSlice();
4806#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4807 Request::__read(__inS, true);
4808#else
4809 ::Ehr::Request::__read(__inS, true);
4810#endif
4811}
4812
4813class __F__Ehr__ThirdPartyRequest : public ::Ice::ObjectFactory
4814{
4815public:
4816
4817 virtual ::Ice::ObjectPtr
4818 create(const ::std::string& type)
4819 {
4820 assert(type == ::Ehr::ThirdPartyRequest::ice_staticId());
4821 return new ::Ehr::ThirdPartyRequest;
4822 }
4823
4824 virtual void
4825 destroy()
4826 {
4827 }
4828};
4829
4830static ::Ice::ObjectFactoryPtr __F__Ehr__ThirdPartyRequest_Ptr = new __F__Ehr__ThirdPartyRequest;
4831
4832const ::Ice::ObjectFactoryPtr&
4833Ehr::ThirdPartyRequest::ice_factory()
4834{
4835 return __F__Ehr__ThirdPartyRequest_Ptr;
4836}
4837
4838class __F__Ehr__ThirdPartyRequest__Init
4839{
4840public:
4841
4842 __F__Ehr__ThirdPartyRequest__Init()
4843 {
4844 ::IceInternal::factoryTable->addObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId(), ::Ehr::ThirdPartyRequest::ice_factory());
4845 }
4846
4847 ~__F__Ehr__ThirdPartyRequest__Init()
4848 {
4849 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId());
4850 }
4851};
4852
4853static __F__Ehr__ThirdPartyRequest__Init __F__Ehr__ThirdPartyRequest__i;
4854
4855#ifdef __APPLE__
4856extern "C" { void __F__Ehr__ThirdPartyRequest__initializer() {} }
4857#endif
4858
4859void
4860Ehr::__patch__ThirdPartyRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
4861{
4862 ::Ehr::ThirdPartyRequestPtr* p = static_cast< ::Ehr::ThirdPartyRequestPtr*>(__addr);
4863 assert(p);
4864 *p = ::Ehr::ThirdPartyRequestPtr::dynamicCast(v);
4865 if(v && !*p)
4866 {
4867 IceInternal::Ex::throwUOE(::Ehr::ThirdPartyRequest::ice_staticId(), v->ice_id());
4868 }
4869}
4870
4871bool
4872Ehr::operator==(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
4873{
4874 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
4875}
4876
4877bool
4878Ehr::operator<(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
4879{
4880 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
4881}
4882
4883Ehr::CreatePrescriptionRequest::CreatePrescriptionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, const ::Ehr::EncryptedDocument& __ice_prescription) :
4884#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4885 Request(__ice_requestor, __ice_when)
4886#else
4887 ::Ehr::Request(__ice_requestor, __ice_when)
4888#endif
4889,
4890#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4891 ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
4892#else
4893 ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
4894#endif
4895,
4896 prescription(__ice_prescription)
4897{
4898}
4899
4900::Ice::ObjectPtr
4901Ehr::CreatePrescriptionRequest::ice_clone() const
4902{
4903 ::Ehr::CreatePrescriptionRequestPtr __p = new ::Ehr::CreatePrescriptionRequest(*this);
4904 return __p;
4905}
4906
4907static const ::std::string __Ehr__CreatePrescriptionRequest_ids[4] =
4908{
4909 "::Ehr::CreatePrescriptionRequest",
4910 "::Ehr::Request",
4911 "::Ehr::ThirdPartyRequest",
4912 "::Ice::Object"
4913};
4914
4915bool
4916Ehr::CreatePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
4917{
4918 return ::std::binary_search(__Ehr__CreatePrescriptionRequest_ids, __Ehr__CreatePrescriptionRequest_ids + 4, _s);
4919}
4920
4921::std::vector< ::std::string>
4922Ehr::CreatePrescriptionRequest::ice_ids(const ::Ice::Current&) const
4923{
4924 return ::std::vector< ::std::string>(&__Ehr__CreatePrescriptionRequest_ids[0], &__Ehr__CreatePrescriptionRequest_ids[4]);
4925}
4926
4927const ::std::string&
4928Ehr::CreatePrescriptionRequest::ice_id(const ::Ice::Current&) const
4929{
4930 return __Ehr__CreatePrescriptionRequest_ids[0];
4931}
4932
4933const ::std::string&
4934Ehr::CreatePrescriptionRequest::ice_staticId()
4935{
4936 return __Ehr__CreatePrescriptionRequest_ids[0];
4937}
4938
4939void
4940Ehr::CreatePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
4941{
4942 __os->writeTypeId(ice_staticId());
4943 __os->startWriteSlice();
4944 prescription.__write(__os);
4945 __os->endWriteSlice();
4946#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4947 ThirdPartyRequest::__write(__os);
4948#else
4949 ::Ehr::ThirdPartyRequest::__write(__os);
4950#endif
4951}
4952
4953void
4954Ehr::CreatePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
4955{
4956 if(__rid)
4957 {
4958 ::std::string myId;
4959 __is->readTypeId(myId);
4960 }
4961 __is->startReadSlice();
4962 prescription.__read(__is);
4963 __is->endReadSlice();
4964#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4965 ThirdPartyRequest::__read(__is, true);
4966#else
4967 ::Ehr::ThirdPartyRequest::__read(__is, true);
4968#endif
4969}
4970
4971void
4972Ehr::CreatePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
4973{
4974 __outS->writeTypeId(ice_staticId());
4975 __outS->startSlice();
4976 ::Ehr::ice_writeEncryptedDocument(__outS, prescription);
4977 __outS->endSlice();
4978#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4979 ThirdPartyRequest::__write(__outS);
4980#else
4981 ::Ehr::ThirdPartyRequest::__write(__outS);
4982#endif
4983}
4984
4985void
4986Ehr::CreatePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
4987{
4988 if(__rid)
4989 {
4990 __inS->readTypeId();
4991 }
4992 __inS->startSlice();
4993 ::Ehr::ice_readEncryptedDocument(__inS, prescription);
4994 __inS->endSlice();
4995#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
4996 ThirdPartyRequest::__read(__inS, true);
4997#else
4998 ::Ehr::ThirdPartyRequest::__read(__inS, true);
4999#endif
5000}
5001
5002class __F__Ehr__CreatePrescriptionRequest : public ::Ice::ObjectFactory
5003{
5004public:
5005
5006 virtual ::Ice::ObjectPtr
5007 create(const ::std::string& type)
5008 {
5009 assert(type == ::Ehr::CreatePrescriptionRequest::ice_staticId());
5010 return new ::Ehr::CreatePrescriptionRequest;
5011 }
5012
5013 virtual void
5014 destroy()
5015 {
5016 }
5017};
5018
5019static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePrescriptionRequest_Ptr = new __F__Ehr__CreatePrescriptionRequest;
5020
5021const ::Ice::ObjectFactoryPtr&
5022Ehr::CreatePrescriptionRequest::ice_factory()
5023{
5024 return __F__Ehr__CreatePrescriptionRequest_Ptr;
5025}
5026
5027class __F__Ehr__CreatePrescriptionRequest__Init
5028{
5029public:
5030
5031 __F__Ehr__CreatePrescriptionRequest__Init()
5032 {
5033 ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId(), ::Ehr::CreatePrescriptionRequest::ice_factory());
5034 }
5035
5036 ~__F__Ehr__CreatePrescriptionRequest__Init()
5037 {
5038 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId());
5039 }
5040};
5041
5042static __F__Ehr__CreatePrescriptionRequest__Init __F__Ehr__CreatePrescriptionRequest__i;
5043
5044#ifdef __APPLE__
5045extern "C" { void __F__Ehr__CreatePrescriptionRequest__initializer() {} }
5046#endif
5047
5048void
5049Ehr::__patch__CreatePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
5050{
5051 ::Ehr::CreatePrescriptionRequestPtr* p = static_cast< ::Ehr::CreatePrescriptionRequestPtr*>(__addr);
5052 assert(p);
5053 *p = ::Ehr::CreatePrescriptionRequestPtr::dynamicCast(v);
5054 if(v && !*p)
5055 {
5056 IceInternal::Ex::throwUOE(::Ehr::CreatePrescriptionRequest::ice_staticId(), v->ice_id());
5057 }
5058}
5059
5060bool
5061Ehr::operator==(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
5062{
5063 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
5064}
5065
5066bool
5067Ehr::operator<(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
5068{
5069 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
5070}
5071
5072Ehr::ConsumePrescriptionRequest::ConsumePrescriptionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, ::Ice::Long __ice_prescriptionId, const ::Ehr::EncryptedDocument& __ice_consumedPrescription) :
5073#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5074 Request(__ice_requestor, __ice_when)
5075#else
5076 ::Ehr::Request(__ice_requestor, __ice_when)
5077#endif
5078,
5079#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5080 ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5081#else
5082 ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5083#endif
5084,
5085 prescriptionId(__ice_prescriptionId),
5086 consumedPrescription(__ice_consumedPrescription)
5087{
5088}
5089
5090::Ice::ObjectPtr
5091Ehr::ConsumePrescriptionRequest::ice_clone() const
5092{
5093 ::Ehr::ConsumePrescriptionRequestPtr __p = new ::Ehr::ConsumePrescriptionRequest(*this);
5094 return __p;
5095}
5096
5097static const ::std::string __Ehr__ConsumePrescriptionRequest_ids[4] =
5098{
5099 "::Ehr::ConsumePrescriptionRequest",
5100 "::Ehr::Request",
5101 "::Ehr::ThirdPartyRequest",
5102 "::Ice::Object"
5103};
5104
5105bool
5106Ehr::ConsumePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
5107{
5108 return ::std::binary_search(__Ehr__ConsumePrescriptionRequest_ids, __Ehr__ConsumePrescriptionRequest_ids + 4, _s);
5109}
5110
5111::std::vector< ::std::string>
5112Ehr::ConsumePrescriptionRequest::ice_ids(const ::Ice::Current&) const
5113{
5114 return ::std::vector< ::std::string>(&__Ehr__ConsumePrescriptionRequest_ids[0], &__Ehr__ConsumePrescriptionRequest_ids[4]);
5115}
5116
5117const ::std::string&
5118Ehr::ConsumePrescriptionRequest::ice_id(const ::Ice::Current&) const
5119{
5120 return __Ehr__ConsumePrescriptionRequest_ids[0];
5121}
5122
5123const ::std::string&
5124Ehr::ConsumePrescriptionRequest::ice_staticId()
5125{
5126 return __Ehr__ConsumePrescriptionRequest_ids[0];
5127}
5128
5129void
5130Ehr::ConsumePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
5131{
5132 __os->writeTypeId(ice_staticId());
5133 __os->startWriteSlice();
5134 __os->write(prescriptionId);
5135 consumedPrescription.__write(__os);
5136 __os->endWriteSlice();
5137#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5138 ThirdPartyRequest::__write(__os);
5139#else
5140 ::Ehr::ThirdPartyRequest::__write(__os);
5141#endif
5142}
5143
5144void
5145Ehr::ConsumePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
5146{
5147 if(__rid)
5148 {
5149 ::std::string myId;
5150 __is->readTypeId(myId);
5151 }
5152 __is->startReadSlice();
5153 __is->read(prescriptionId);
5154 consumedPrescription.__read(__is);
5155 __is->endReadSlice();
5156#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5157 ThirdPartyRequest::__read(__is, true);
5158#else
5159 ::Ehr::ThirdPartyRequest::__read(__is, true);
5160#endif
5161}
5162
5163void
5164Ehr::ConsumePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
5165{
5166 __outS->writeTypeId(ice_staticId());
5167 __outS->startSlice();
5168 __outS->writeLong(prescriptionId);
5169 ::Ehr::ice_writeEncryptedDocument(__outS, consumedPrescription);
5170 __outS->endSlice();
5171#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5172 ThirdPartyRequest::__write(__outS);
5173#else
5174 ::Ehr::ThirdPartyRequest::__write(__outS);
5175#endif
5176}
5177
5178void
5179Ehr::ConsumePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
5180{
5181 if(__rid)
5182 {
5183 __inS->readTypeId();
5184 }
5185 __inS->startSlice();
5186 prescriptionId = __inS->readLong();
5187 ::Ehr::ice_readEncryptedDocument(__inS, consumedPrescription);
5188 __inS->endSlice();
5189#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5190 ThirdPartyRequest::__read(__inS, true);
5191#else
5192 ::Ehr::ThirdPartyRequest::__read(__inS, true);
5193#endif
5194}
5195
5196class __F__Ehr__ConsumePrescriptionRequest : public ::Ice::ObjectFactory
5197{
5198public:
5199
5200 virtual ::Ice::ObjectPtr
5201 create(const ::std::string& type)
5202 {
5203 assert(type == ::Ehr::ConsumePrescriptionRequest::ice_staticId());
5204 return new ::Ehr::ConsumePrescriptionRequest;
5205 }
5206
5207 virtual void
5208 destroy()
5209 {
5210 }
5211};
5212
5213static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumePrescriptionRequest_Ptr = new __F__Ehr__ConsumePrescriptionRequest;
5214
5215const ::Ice::ObjectFactoryPtr&
5216Ehr::ConsumePrescriptionRequest::ice_factory()
5217{
5218 return __F__Ehr__ConsumePrescriptionRequest_Ptr;
5219}
5220
5221class __F__Ehr__ConsumePrescriptionRequest__Init
5222{
5223public:
5224
5225 __F__Ehr__ConsumePrescriptionRequest__Init()
5226 {
5227 ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId(), ::Ehr::ConsumePrescriptionRequest::ice_factory());
5228 }
5229
5230 ~__F__Ehr__ConsumePrescriptionRequest__Init()
5231 {
5232 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId());
5233 }
5234};
5235
5236static __F__Ehr__ConsumePrescriptionRequest__Init __F__Ehr__ConsumePrescriptionRequest__i;
5237
5238#ifdef __APPLE__
5239extern "C" { void __F__Ehr__ConsumePrescriptionRequest__initializer() {} }
5240#endif
5241
5242void
5243Ehr::__patch__ConsumePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
5244{
5245 ::Ehr::ConsumePrescriptionRequestPtr* p = static_cast< ::Ehr::ConsumePrescriptionRequestPtr*>(__addr);
5246 assert(p);
5247 *p = ::Ehr::ConsumePrescriptionRequestPtr::dynamicCast(v);
5248 if(v && !*p)
5249 {
5250 IceInternal::Ex::throwUOE(::Ehr::ConsumePrescriptionRequest::ice_staticId(), v->ice_id());
5251 }
5252}
5253
5254bool
5255Ehr::operator==(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
5256{
5257 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
5258}
5259
5260bool
5261Ehr::operator<(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
5262{
5263 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
5264}
5265
5266Ehr::ListDocumentsRequest::ListDocumentsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
5267#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5268 Request(__ice_requestor, __ice_when)
5269#else
5270 ::Ehr::Request(__ice_requestor, __ice_when)
5271#endif
5272,
5273#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5274 ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5275#else
5276 ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5277#endif
5278
5279{
5280}
5281
5282::Ice::ObjectPtr
5283Ehr::ListDocumentsRequest::ice_clone() const
5284{
5285 ::Ehr::ListDocumentsRequestPtr __p = new ::Ehr::ListDocumentsRequest(*this);
5286 return __p;
5287}
5288
5289static const ::std::string __Ehr__ListDocumentsRequest_ids[4] =
5290{
5291 "::Ehr::ListDocumentsRequest",
5292 "::Ehr::Request",
5293 "::Ehr::ThirdPartyRequest",
5294 "::Ice::Object"
5295};
5296
5297bool
5298Ehr::ListDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
5299{
5300 return ::std::binary_search(__Ehr__ListDocumentsRequest_ids, __Ehr__ListDocumentsRequest_ids + 4, _s);
5301}
5302
5303::std::vector< ::std::string>
5304Ehr::ListDocumentsRequest::ice_ids(const ::Ice::Current&) const
5305{
5306 return ::std::vector< ::std::string>(&__Ehr__ListDocumentsRequest_ids[0], &__Ehr__ListDocumentsRequest_ids[4]);
5307}
5308
5309const ::std::string&
5310Ehr::ListDocumentsRequest::ice_id(const ::Ice::Current&) const
5311{
5312 return __Ehr__ListDocumentsRequest_ids[0];
5313}
5314
5315const ::std::string&
5316Ehr::ListDocumentsRequest::ice_staticId()
5317{
5318 return __Ehr__ListDocumentsRequest_ids[0];
5319}
5320
5321void
5322Ehr::ListDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
5323{
5324 __os->writeTypeId(ice_staticId());
5325 __os->startWriteSlice();
5326 __os->endWriteSlice();
5327#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5328 ThirdPartyRequest::__write(__os);
5329#else
5330 ::Ehr::ThirdPartyRequest::__write(__os);
5331#endif
5332}
5333
5334void
5335Ehr::ListDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
5336{
5337 if(__rid)
5338 {
5339 ::std::string myId;
5340 __is->readTypeId(myId);
5341 }
5342 __is->startReadSlice();
5343 __is->endReadSlice();
5344#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5345 ThirdPartyRequest::__read(__is, true);
5346#else
5347 ::Ehr::ThirdPartyRequest::__read(__is, true);
5348#endif
5349}
5350
5351void
5352Ehr::ListDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
5353{
5354 __outS->writeTypeId(ice_staticId());
5355 __outS->startSlice();
5356 __outS->endSlice();
5357#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5358 ThirdPartyRequest::__write(__outS);
5359#else
5360 ::Ehr::ThirdPartyRequest::__write(__outS);
5361#endif
5362}
5363
5364void
5365Ehr::ListDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
5366{
5367 if(__rid)
5368 {
5369 __inS->readTypeId();
5370 }
5371 __inS->startSlice();
5372 __inS->endSlice();
5373#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5374 ThirdPartyRequest::__read(__inS, true);
5375#else
5376 ::Ehr::ThirdPartyRequest::__read(__inS, true);
5377#endif
5378}
5379
5380class __F__Ehr__ListDocumentsRequest : public ::Ice::ObjectFactory
5381{
5382public:
5383
5384 virtual ::Ice::ObjectPtr
5385 create(const ::std::string& type)
5386 {
5387 assert(type == ::Ehr::ListDocumentsRequest::ice_staticId());
5388 return new ::Ehr::ListDocumentsRequest;
5389 }
5390
5391 virtual void
5392 destroy()
5393 {
5394 }
5395};
5396
5397static ::Ice::ObjectFactoryPtr __F__Ehr__ListDocumentsRequest_Ptr = new __F__Ehr__ListDocumentsRequest;
5398
5399const ::Ice::ObjectFactoryPtr&
5400Ehr::ListDocumentsRequest::ice_factory()
5401{
5402 return __F__Ehr__ListDocumentsRequest_Ptr;
5403}
5404
5405class __F__Ehr__ListDocumentsRequest__Init
5406{
5407public:
5408
5409 __F__Ehr__ListDocumentsRequest__Init()
5410 {
5411 ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId(), ::Ehr::ListDocumentsRequest::ice_factory());
5412 }
5413
5414 ~__F__Ehr__ListDocumentsRequest__Init()
5415 {
5416 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId());
5417 }
5418};
5419
5420static __F__Ehr__ListDocumentsRequest__Init __F__Ehr__ListDocumentsRequest__i;
5421
5422#ifdef __APPLE__
5423extern "C" { void __F__Ehr__ListDocumentsRequest__initializer() {} }
5424#endif
5425
5426void
5427Ehr::__patch__ListDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
5428{
5429 ::Ehr::ListDocumentsRequestPtr* p = static_cast< ::Ehr::ListDocumentsRequestPtr*>(__addr);
5430 assert(p);
5431 *p = ::Ehr::ListDocumentsRequestPtr::dynamicCast(v);
5432 if(v && !*p)
5433 {
5434 IceInternal::Ex::throwUOE(::Ehr::ListDocumentsRequest::ice_staticId(), v->ice_id());
5435 }
5436}
5437
5438bool
5439Ehr::operator==(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
5440{
5441 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
5442}
5443
5444bool
5445Ehr::operator<(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
5446{
5447 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
5448}
5449
5450Ehr::FindDocumentsRequest::FindDocumentsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, bool __ice_hasFrom, const ::Ehr::Timestamp& __ice_from, bool __ice_hasTill, const ::Ehr::Timestamp& __ice_till, ::Ehr::DocumentType __ice_type, ::Ice::Long __ice_documentId) :
5451#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5452 Request(__ice_requestor, __ice_when)
5453#else
5454 ::Ehr::Request(__ice_requestor, __ice_when)
5455#endif
5456,
5457#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5458 ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5459#else
5460 ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
5461#endif
5462,
5463 hasFrom(__ice_hasFrom),
5464 from(__ice_from),
5465 hasTill(__ice_hasTill),
5466 till(__ice_till),
5467 type(__ice_type),
5468 documentId(__ice_documentId)
5469{
5470}
5471
5472::Ice::ObjectPtr
5473Ehr::FindDocumentsRequest::ice_clone() const
5474{
5475 ::Ehr::FindDocumentsRequestPtr __p = new ::Ehr::FindDocumentsRequest(*this);
5476 return __p;
5477}
5478
5479static const ::std::string __Ehr__FindDocumentsRequest_ids[4] =
5480{
5481 "::Ehr::FindDocumentsRequest",
5482 "::Ehr::Request",
5483 "::Ehr::ThirdPartyRequest",
5484 "::Ice::Object"
5485};
5486
5487bool
5488Ehr::FindDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
5489{
5490 return ::std::binary_search(__Ehr__FindDocumentsRequest_ids, __Ehr__FindDocumentsRequest_ids + 4, _s);
5491}
5492
5493::std::vector< ::std::string>
5494Ehr::FindDocumentsRequest::ice_ids(const ::Ice::Current&) const
5495{
5496 return ::std::vector< ::std::string>(&__Ehr__FindDocumentsRequest_ids[0], &__Ehr__FindDocumentsRequest_ids[4]);
5497}
5498
5499const ::std::string&
5500Ehr::FindDocumentsRequest::ice_id(const ::Ice::Current&) const
5501{
5502 return __Ehr__FindDocumentsRequest_ids[0];
5503}
5504
5505const ::std::string&
5506Ehr::FindDocumentsRequest::ice_staticId()
5507{
5508 return __Ehr__FindDocumentsRequest_ids[0];
5509}
5510
5511void
5512Ehr::FindDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
5513{
5514 __os->writeTypeId(ice_staticId());
5515 __os->startWriteSlice();
5516 __os->write(hasFrom);
5517 from.__write(__os);
5518 __os->write(hasTill);
5519 till.__write(__os);
5520 ::Ehr::__write(__os, type);
5521 __os->write(documentId);
5522 __os->endWriteSlice();
5523#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5524 ThirdPartyRequest::__write(__os);
5525#else
5526 ::Ehr::ThirdPartyRequest::__write(__os);
5527#endif
5528}
5529
5530void
5531Ehr::FindDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
5532{
5533 if(__rid)
5534 {
5535 ::std::string myId;
5536 __is->readTypeId(myId);
5537 }
5538 __is->startReadSlice();
5539 __is->read(hasFrom);
5540 from.__read(__is);
5541 __is->read(hasTill);
5542 till.__read(__is);
5543 ::Ehr::__read(__is, type);
5544 __is->read(documentId);
5545 __is->endReadSlice();
5546#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5547 ThirdPartyRequest::__read(__is, true);
5548#else
5549 ::Ehr::ThirdPartyRequest::__read(__is, true);
5550#endif
5551}
5552
5553void
5554Ehr::FindDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
5555{
5556 __outS->writeTypeId(ice_staticId());
5557 __outS->startSlice();
5558 __outS->writeBool(hasFrom);
5559 ::Ehr::ice_writeTimestamp(__outS, from);
5560 __outS->writeBool(hasTill);
5561 ::Ehr::ice_writeTimestamp(__outS, till);
5562 ::Ehr::ice_writeDocumentType(__outS, type);
5563 __outS->writeLong(documentId);
5564 __outS->endSlice();
5565#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5566 ThirdPartyRequest::__write(__outS);
5567#else
5568 ::Ehr::ThirdPartyRequest::__write(__outS);
5569#endif
5570}
5571
5572void
5573Ehr::FindDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
5574{
5575 if(__rid)
5576 {
5577 __inS->readTypeId();
5578 }
5579 __inS->startSlice();
5580 hasFrom = __inS->readBool();
5581 ::Ehr::ice_readTimestamp(__inS, from);
5582 hasTill = __inS->readBool();
5583 ::Ehr::ice_readTimestamp(__inS, till);
5584 ::Ehr::ice_readDocumentType(__inS, type);
5585 documentId = __inS->readLong();
5586 __inS->endSlice();
5587#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5588 ThirdPartyRequest::__read(__inS, true);
5589#else
5590 ::Ehr::ThirdPartyRequest::__read(__inS, true);
5591#endif
5592}
5593
5594class __F__Ehr__FindDocumentsRequest : public ::Ice::ObjectFactory
5595{
5596public:
5597
5598 virtual ::Ice::ObjectPtr
5599 create(const ::std::string& type)
5600 {
5601 assert(type == ::Ehr::FindDocumentsRequest::ice_staticId());
5602 return new ::Ehr::FindDocumentsRequest;
5603 }
5604
5605 virtual void
5606 destroy()
5607 {
5608 }
5609};
5610
5611static ::Ice::ObjectFactoryPtr __F__Ehr__FindDocumentsRequest_Ptr = new __F__Ehr__FindDocumentsRequest;
5612
5613const ::Ice::ObjectFactoryPtr&
5614Ehr::FindDocumentsRequest::ice_factory()
5615{
5616 return __F__Ehr__FindDocumentsRequest_Ptr;
5617}
5618
5619class __F__Ehr__FindDocumentsRequest__Init
5620{
5621public:
5622
5623 __F__Ehr__FindDocumentsRequest__Init()
5624 {
5625 ::IceInternal::factoryTable->addObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId(), ::Ehr::FindDocumentsRequest::ice_factory());
5626 }
5627
5628 ~__F__Ehr__FindDocumentsRequest__Init()
5629 {
5630 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId());
5631 }
5632};
5633
5634static __F__Ehr__FindDocumentsRequest__Init __F__Ehr__FindDocumentsRequest__i;
5635
5636#ifdef __APPLE__
5637extern "C" { void __F__Ehr__FindDocumentsRequest__initializer() {} }
5638#endif
5639
5640void
5641Ehr::__patch__FindDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
5642{
5643 ::Ehr::FindDocumentsRequestPtr* p = static_cast< ::Ehr::FindDocumentsRequestPtr*>(__addr);
5644 assert(p);
5645 *p = ::Ehr::FindDocumentsRequestPtr::dynamicCast(v);
5646 if(v && !*p)
5647 {
5648 IceInternal::Ex::throwUOE(::Ehr::FindDocumentsRequest::ice_staticId(), v->ice_id());
5649 }
5650}
5651
5652bool
5653Ehr::operator==(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
5654{
5655 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
5656}
5657
5658bool
5659Ehr::operator<(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
5660{
5661 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
5662}
5663
5664Ehr::CreatePermissionRequest::CreatePermissionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, const ::Ehr::AccountIdentifier& __ice_account, ::Ehr::AccessType __ice_access) :
5665#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5666 Request(__ice_requestor, __ice_when)
5667#else
5668 ::Ehr::Request(__ice_requestor, __ice_when)
5669#endif
5670,
5671 documentId(__ice_documentId),
5672 account(__ice_account),
5673 access(__ice_access)
5674{
5675}
5676
5677::Ice::ObjectPtr
5678Ehr::CreatePermissionRequest::ice_clone() const
5679{
5680 ::Ehr::CreatePermissionRequestPtr __p = new ::Ehr::CreatePermissionRequest(*this);
5681 return __p;
5682}
5683
5684static const ::std::string __Ehr__CreatePermissionRequest_ids[3] =
5685{
5686 "::Ehr::CreatePermissionRequest",
5687 "::Ehr::Request",
5688 "::Ice::Object"
5689};
5690
5691bool
5692Ehr::CreatePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
5693{
5694 return ::std::binary_search(__Ehr__CreatePermissionRequest_ids, __Ehr__CreatePermissionRequest_ids + 3, _s);
5695}
5696
5697::std::vector< ::std::string>
5698Ehr::CreatePermissionRequest::ice_ids(const ::Ice::Current&) const
5699{
5700 return ::std::vector< ::std::string>(&__Ehr__CreatePermissionRequest_ids[0], &__Ehr__CreatePermissionRequest_ids[3]);
5701}
5702
5703const ::std::string&
5704Ehr::CreatePermissionRequest::ice_id(const ::Ice::Current&) const
5705{
5706 return __Ehr__CreatePermissionRequest_ids[0];
5707}
5708
5709const ::std::string&
5710Ehr::CreatePermissionRequest::ice_staticId()
5711{
5712 return __Ehr__CreatePermissionRequest_ids[0];
5713}
5714
5715void
5716Ehr::CreatePermissionRequest::__write(::IceInternal::BasicStream* __os) const
5717{
5718 __os->writeTypeId(ice_staticId());
5719 __os->startWriteSlice();
5720 __os->write(documentId);
5721 account.__write(__os);
5722 ::Ehr::__write(__os, access);
5723 __os->endWriteSlice();
5724#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5725 Request::__write(__os);
5726#else
5727 ::Ehr::Request::__write(__os);
5728#endif
5729}
5730
5731void
5732Ehr::CreatePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
5733{
5734 if(__rid)
5735 {
5736 ::std::string myId;
5737 __is->readTypeId(myId);
5738 }
5739 __is->startReadSlice();
5740 __is->read(documentId);
5741 account.__read(__is);
5742 ::Ehr::__read(__is, access);
5743 __is->endReadSlice();
5744#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5745 Request::__read(__is, true);
5746#else
5747 ::Ehr::Request::__read(__is, true);
5748#endif
5749}
5750
5751void
5752Ehr::CreatePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
5753{
5754 __outS->writeTypeId(ice_staticId());
5755 __outS->startSlice();
5756 __outS->writeLong(documentId);
5757 ::Ehr::ice_writeAccountIdentifier(__outS, account);
5758 ::Ehr::ice_writeAccessType(__outS, access);
5759 __outS->endSlice();
5760#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5761 Request::__write(__outS);
5762#else
5763 ::Ehr::Request::__write(__outS);
5764#endif
5765}
5766
5767void
5768Ehr::CreatePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
5769{
5770 if(__rid)
5771 {
5772 __inS->readTypeId();
5773 }
5774 __inS->startSlice();
5775 documentId = __inS->readLong();
5776 ::Ehr::ice_readAccountIdentifier(__inS, account);
5777 ::Ehr::ice_readAccessType(__inS, access);
5778 __inS->endSlice();
5779#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5780 Request::__read(__inS, true);
5781#else
5782 ::Ehr::Request::__read(__inS, true);
5783#endif
5784}
5785
5786class __F__Ehr__CreatePermissionRequest : public ::Ice::ObjectFactory
5787{
5788public:
5789
5790 virtual ::Ice::ObjectPtr
5791 create(const ::std::string& type)
5792 {
5793 assert(type == ::Ehr::CreatePermissionRequest::ice_staticId());
5794 return new ::Ehr::CreatePermissionRequest;
5795 }
5796
5797 virtual void
5798 destroy()
5799 {
5800 }
5801};
5802
5803static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePermissionRequest_Ptr = new __F__Ehr__CreatePermissionRequest;
5804
5805const ::Ice::ObjectFactoryPtr&
5806Ehr::CreatePermissionRequest::ice_factory()
5807{
5808 return __F__Ehr__CreatePermissionRequest_Ptr;
5809}
5810
5811class __F__Ehr__CreatePermissionRequest__Init
5812{
5813public:
5814
5815 __F__Ehr__CreatePermissionRequest__Init()
5816 {
5817 ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId(), ::Ehr::CreatePermissionRequest::ice_factory());
5818 }
5819
5820 ~__F__Ehr__CreatePermissionRequest__Init()
5821 {
5822 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId());
5823 }
5824};
5825
5826static __F__Ehr__CreatePermissionRequest__Init __F__Ehr__CreatePermissionRequest__i;
5827
5828#ifdef __APPLE__
5829extern "C" { void __F__Ehr__CreatePermissionRequest__initializer() {} }
5830#endif
5831
5832void
5833Ehr::__patch__CreatePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
5834{
5835 ::Ehr::CreatePermissionRequestPtr* p = static_cast< ::Ehr::CreatePermissionRequestPtr*>(__addr);
5836 assert(p);
5837 *p = ::Ehr::CreatePermissionRequestPtr::dynamicCast(v);
5838 if(v && !*p)
5839 {
5840 IceInternal::Ex::throwUOE(::Ehr::CreatePermissionRequest::ice_staticId(), v->ice_id());
5841 }
5842}
5843
5844bool
5845Ehr::operator==(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
5846{
5847 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
5848}
5849
5850bool
5851Ehr::operator<(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
5852{
5853 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
5854}
5855
5856Ehr::SetDefaultAccessRequest::SetDefaultAccessRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ehr::AccessType __ice_access) :
5857#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5858 Request(__ice_requestor, __ice_when)
5859#else
5860 ::Ehr::Request(__ice_requestor, __ice_when)
5861#endif
5862,
5863 documentId(__ice_documentId),
5864 access(__ice_access)
5865{
5866}
5867
5868::Ice::ObjectPtr
5869Ehr::SetDefaultAccessRequest::ice_clone() const
5870{
5871 ::Ehr::SetDefaultAccessRequestPtr __p = new ::Ehr::SetDefaultAccessRequest(*this);
5872 return __p;
5873}
5874
5875static const ::std::string __Ehr__SetDefaultAccessRequest_ids[3] =
5876{
5877 "::Ehr::Request",
5878 "::Ehr::SetDefaultAccessRequest",
5879 "::Ice::Object"
5880};
5881
5882bool
5883Ehr::SetDefaultAccessRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
5884{
5885 return ::std::binary_search(__Ehr__SetDefaultAccessRequest_ids, __Ehr__SetDefaultAccessRequest_ids + 3, _s);
5886}
5887
5888::std::vector< ::std::string>
5889Ehr::SetDefaultAccessRequest::ice_ids(const ::Ice::Current&) const
5890{
5891 return ::std::vector< ::std::string>(&__Ehr__SetDefaultAccessRequest_ids[0], &__Ehr__SetDefaultAccessRequest_ids[3]);
5892}
5893
5894const ::std::string&
5895Ehr::SetDefaultAccessRequest::ice_id(const ::Ice::Current&) const
5896{
5897 return __Ehr__SetDefaultAccessRequest_ids[1];
5898}
5899
5900const ::std::string&
5901Ehr::SetDefaultAccessRequest::ice_staticId()
5902{
5903 return __Ehr__SetDefaultAccessRequest_ids[1];
5904}
5905
5906void
5907Ehr::SetDefaultAccessRequest::__write(::IceInternal::BasicStream* __os) const
5908{
5909 __os->writeTypeId(ice_staticId());
5910 __os->startWriteSlice();
5911 __os->write(documentId);
5912 ::Ehr::__write(__os, access);
5913 __os->endWriteSlice();
5914#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5915 Request::__write(__os);
5916#else
5917 ::Ehr::Request::__write(__os);
5918#endif
5919}
5920
5921void
5922Ehr::SetDefaultAccessRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
5923{
5924 if(__rid)
5925 {
5926 ::std::string myId;
5927 __is->readTypeId(myId);
5928 }
5929 __is->startReadSlice();
5930 __is->read(documentId);
5931 ::Ehr::__read(__is, access);
5932 __is->endReadSlice();
5933#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5934 Request::__read(__is, true);
5935#else
5936 ::Ehr::Request::__read(__is, true);
5937#endif
5938}
5939
5940void
5941Ehr::SetDefaultAccessRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
5942{
5943 __outS->writeTypeId(ice_staticId());
5944 __outS->startSlice();
5945 __outS->writeLong(documentId);
5946 ::Ehr::ice_writeAccessType(__outS, access);
5947 __outS->endSlice();
5948#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5949 Request::__write(__outS);
5950#else
5951 ::Ehr::Request::__write(__outS);
5952#endif
5953}
5954
5955void
5956Ehr::SetDefaultAccessRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
5957{
5958 if(__rid)
5959 {
5960 __inS->readTypeId();
5961 }
5962 __inS->startSlice();
5963 documentId = __inS->readLong();
5964 ::Ehr::ice_readAccessType(__inS, access);
5965 __inS->endSlice();
5966#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
5967 Request::__read(__inS, true);
5968#else
5969 ::Ehr::Request::__read(__inS, true);
5970#endif
5971}
5972
5973class __F__Ehr__SetDefaultAccessRequest : public ::Ice::ObjectFactory
5974{
5975public:
5976
5977 virtual ::Ice::ObjectPtr
5978 create(const ::std::string& type)
5979 {
5980 assert(type == ::Ehr::SetDefaultAccessRequest::ice_staticId());
5981 return new ::Ehr::SetDefaultAccessRequest;
5982 }
5983
5984 virtual void
5985 destroy()
5986 {
5987 }
5988};
5989
5990static ::Ice::ObjectFactoryPtr __F__Ehr__SetDefaultAccessRequest_Ptr = new __F__Ehr__SetDefaultAccessRequest;
5991
5992const ::Ice::ObjectFactoryPtr&
5993Ehr::SetDefaultAccessRequest::ice_factory()
5994{
5995 return __F__Ehr__SetDefaultAccessRequest_Ptr;
5996}
5997
5998class __F__Ehr__SetDefaultAccessRequest__Init
5999{
6000public:
6001
6002 __F__Ehr__SetDefaultAccessRequest__Init()
6003 {
6004 ::IceInternal::factoryTable->addObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId(), ::Ehr::SetDefaultAccessRequest::ice_factory());
6005 }
6006
6007 ~__F__Ehr__SetDefaultAccessRequest__Init()
6008 {
6009 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId());
6010 }
6011};
6012
6013static __F__Ehr__SetDefaultAccessRequest__Init __F__Ehr__SetDefaultAccessRequest__i;
6014
6015#ifdef __APPLE__
6016extern "C" { void __F__Ehr__SetDefaultAccessRequest__initializer() {} }
6017#endif
6018
6019void
6020Ehr::__patch__SetDefaultAccessRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
6021{
6022 ::Ehr::SetDefaultAccessRequestPtr* p = static_cast< ::Ehr::SetDefaultAccessRequestPtr*>(__addr);
6023 assert(p);
6024 *p = ::Ehr::SetDefaultAccessRequestPtr::dynamicCast(v);
6025 if(v && !*p)
6026 {
6027 IceInternal::Ex::throwUOE(::Ehr::SetDefaultAccessRequest::ice_staticId(), v->ice_id());
6028 }
6029}
6030
6031bool
6032Ehr::operator==(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
6033{
6034 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
6035}
6036
6037bool
6038Ehr::operator<(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
6039{
6040 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
6041}
6042
6043Ehr::ListPermissionsRequest::ListPermissionsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId) :
6044#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6045 Request(__ice_requestor, __ice_when)
6046#else
6047 ::Ehr::Request(__ice_requestor, __ice_when)
6048#endif
6049,
6050 documentId(__ice_documentId)
6051{
6052}
6053
6054::Ice::ObjectPtr
6055Ehr::ListPermissionsRequest::ice_clone() const
6056{
6057 ::Ehr::ListPermissionsRequestPtr __p = new ::Ehr::ListPermissionsRequest(*this);
6058 return __p;
6059}
6060
6061static const ::std::string __Ehr__ListPermissionsRequest_ids[3] =
6062{
6063 "::Ehr::ListPermissionsRequest",
6064 "::Ehr::Request",
6065 "::Ice::Object"
6066};
6067
6068bool
6069Ehr::ListPermissionsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
6070{
6071 return ::std::binary_search(__Ehr__ListPermissionsRequest_ids, __Ehr__ListPermissionsRequest_ids + 3, _s);
6072}
6073
6074::std::vector< ::std::string>
6075Ehr::ListPermissionsRequest::ice_ids(const ::Ice::Current&) const
6076{
6077 return ::std::vector< ::std::string>(&__Ehr__ListPermissionsRequest_ids[0], &__Ehr__ListPermissionsRequest_ids[3]);
6078}
6079
6080const ::std::string&
6081Ehr::ListPermissionsRequest::ice_id(const ::Ice::Current&) const
6082{
6083 return __Ehr__ListPermissionsRequest_ids[0];
6084}
6085
6086const ::std::string&
6087Ehr::ListPermissionsRequest::ice_staticId()
6088{
6089 return __Ehr__ListPermissionsRequest_ids[0];
6090}
6091
6092void
6093Ehr::ListPermissionsRequest::__write(::IceInternal::BasicStream* __os) const
6094{
6095 __os->writeTypeId(ice_staticId());
6096 __os->startWriteSlice();
6097 __os->write(documentId);
6098 __os->endWriteSlice();
6099#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6100 Request::__write(__os);
6101#else
6102 ::Ehr::Request::__write(__os);
6103#endif
6104}
6105
6106void
6107Ehr::ListPermissionsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
6108{
6109 if(__rid)
6110 {
6111 ::std::string myId;
6112 __is->readTypeId(myId);
6113 }
6114 __is->startReadSlice();
6115 __is->read(documentId);
6116 __is->endReadSlice();
6117#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6118 Request::__read(__is, true);
6119#else
6120 ::Ehr::Request::__read(__is, true);
6121#endif
6122}
6123
6124void
6125Ehr::ListPermissionsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
6126{
6127 __outS->writeTypeId(ice_staticId());
6128 __outS->startSlice();
6129 __outS->writeLong(documentId);
6130 __outS->endSlice();
6131#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6132 Request::__write(__outS);
6133#else
6134 ::Ehr::Request::__write(__outS);
6135#endif
6136}
6137
6138void
6139Ehr::ListPermissionsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
6140{
6141 if(__rid)
6142 {
6143 __inS->readTypeId();
6144 }
6145 __inS->startSlice();
6146 documentId = __inS->readLong();
6147 __inS->endSlice();
6148#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6149 Request::__read(__inS, true);
6150#else
6151 ::Ehr::Request::__read(__inS, true);
6152#endif
6153}
6154
6155class __F__Ehr__ListPermissionsRequest : public ::Ice::ObjectFactory
6156{
6157public:
6158
6159 virtual ::Ice::ObjectPtr
6160 create(const ::std::string& type)
6161 {
6162 assert(type == ::Ehr::ListPermissionsRequest::ice_staticId());
6163 return new ::Ehr::ListPermissionsRequest;
6164 }
6165
6166 virtual void
6167 destroy()
6168 {
6169 }
6170};
6171
6172static ::Ice::ObjectFactoryPtr __F__Ehr__ListPermissionsRequest_Ptr = new __F__Ehr__ListPermissionsRequest;
6173
6174const ::Ice::ObjectFactoryPtr&
6175Ehr::ListPermissionsRequest::ice_factory()
6176{
6177 return __F__Ehr__ListPermissionsRequest_Ptr;
6178}
6179
6180class __F__Ehr__ListPermissionsRequest__Init
6181{
6182public:
6183
6184 __F__Ehr__ListPermissionsRequest__Init()
6185 {
6186 ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId(), ::Ehr::ListPermissionsRequest::ice_factory());
6187 }
6188
6189 ~__F__Ehr__ListPermissionsRequest__Init()
6190 {
6191 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId());
6192 }
6193};
6194
6195static __F__Ehr__ListPermissionsRequest__Init __F__Ehr__ListPermissionsRequest__i;
6196
6197#ifdef __APPLE__
6198extern "C" { void __F__Ehr__ListPermissionsRequest__initializer() {} }
6199#endif
6200
6201void
6202Ehr::__patch__ListPermissionsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
6203{
6204 ::Ehr::ListPermissionsRequestPtr* p = static_cast< ::Ehr::ListPermissionsRequestPtr*>(__addr);
6205 assert(p);
6206 *p = ::Ehr::ListPermissionsRequestPtr::dynamicCast(v);
6207 if(v && !*p)
6208 {
6209 IceInternal::Ex::throwUOE(::Ehr::ListPermissionsRequest::ice_staticId(), v->ice_id());
6210 }
6211}
6212
6213bool
6214Ehr::operator==(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
6215{
6216 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
6217}
6218
6219bool
6220Ehr::operator<(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
6221{
6222 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
6223}
6224
6225Ehr::RemovePermissionRequest::RemovePermissionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ice::Long __ice_permissionId) :
6226#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6227 Request(__ice_requestor, __ice_when)
6228#else
6229 ::Ehr::Request(__ice_requestor, __ice_when)
6230#endif
6231,
6232 documentId(__ice_documentId),
6233 permissionId(__ice_permissionId)
6234{
6235}
6236
6237::Ice::ObjectPtr
6238Ehr::RemovePermissionRequest::ice_clone() const
6239{
6240 ::Ehr::RemovePermissionRequestPtr __p = new ::Ehr::RemovePermissionRequest(*this);
6241 return __p;
6242}
6243
6244static const ::std::string __Ehr__RemovePermissionRequest_ids[3] =
6245{
6246 "::Ehr::RemovePermissionRequest",
6247 "::Ehr::Request",
6248 "::Ice::Object"
6249};
6250
6251bool
6252Ehr::RemovePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
6253{
6254 return ::std::binary_search(__Ehr__RemovePermissionRequest_ids, __Ehr__RemovePermissionRequest_ids + 3, _s);
6255}
6256
6257::std::vector< ::std::string>
6258Ehr::RemovePermissionRequest::ice_ids(const ::Ice::Current&) const
6259{
6260 return ::std::vector< ::std::string>(&__Ehr__RemovePermissionRequest_ids[0], &__Ehr__RemovePermissionRequest_ids[3]);
6261}
6262
6263const ::std::string&
6264Ehr::RemovePermissionRequest::ice_id(const ::Ice::Current&) const
6265{
6266 return __Ehr__RemovePermissionRequest_ids[0];
6267}
6268
6269const ::std::string&
6270Ehr::RemovePermissionRequest::ice_staticId()
6271{
6272 return __Ehr__RemovePermissionRequest_ids[0];
6273}
6274
6275void
6276Ehr::RemovePermissionRequest::__write(::IceInternal::BasicStream* __os) const
6277{
6278 __os->writeTypeId(ice_staticId());
6279 __os->startWriteSlice();
6280 __os->write(documentId);
6281 __os->write(permissionId);
6282 __os->endWriteSlice();
6283#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6284 Request::__write(__os);
6285#else
6286 ::Ehr::Request::__write(__os);
6287#endif
6288}
6289
6290void
6291Ehr::RemovePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
6292{
6293 if(__rid)
6294 {
6295 ::std::string myId;
6296 __is->readTypeId(myId);
6297 }
6298 __is->startReadSlice();
6299 __is->read(documentId);
6300 __is->read(permissionId);
6301 __is->endReadSlice();
6302#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6303 Request::__read(__is, true);
6304#else
6305 ::Ehr::Request::__read(__is, true);
6306#endif
6307}
6308
6309void
6310Ehr::RemovePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
6311{
6312 __outS->writeTypeId(ice_staticId());
6313 __outS->startSlice();
6314 __outS->writeLong(documentId);
6315 __outS->writeLong(permissionId);
6316 __outS->endSlice();
6317#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6318 Request::__write(__outS);
6319#else
6320 ::Ehr::Request::__write(__outS);
6321#endif
6322}
6323
6324void
6325Ehr::RemovePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
6326{
6327 if(__rid)
6328 {
6329 __inS->readTypeId();
6330 }
6331 __inS->startSlice();
6332 documentId = __inS->readLong();
6333 permissionId = __inS->readLong();
6334 __inS->endSlice();
6335#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6336 Request::__read(__inS, true);
6337#else
6338 ::Ehr::Request::__read(__inS, true);
6339#endif
6340}
6341
6342class __F__Ehr__RemovePermissionRequest : public ::Ice::ObjectFactory
6343{
6344public:
6345
6346 virtual ::Ice::ObjectPtr
6347 create(const ::std::string& type)
6348 {
6349 assert(type == ::Ehr::RemovePermissionRequest::ice_staticId());
6350 return new ::Ehr::RemovePermissionRequest;
6351 }
6352
6353 virtual void
6354 destroy()
6355 {
6356 }
6357};
6358
6359static ::Ice::ObjectFactoryPtr __F__Ehr__RemovePermissionRequest_Ptr = new __F__Ehr__RemovePermissionRequest;
6360
6361const ::Ice::ObjectFactoryPtr&
6362Ehr::RemovePermissionRequest::ice_factory()
6363{
6364 return __F__Ehr__RemovePermissionRequest_Ptr;
6365}
6366
6367class __F__Ehr__RemovePermissionRequest__Init
6368{
6369public:
6370
6371 __F__Ehr__RemovePermissionRequest__Init()
6372 {
6373 ::IceInternal::factoryTable->addObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId(), ::Ehr::RemovePermissionRequest::ice_factory());
6374 }
6375
6376 ~__F__Ehr__RemovePermissionRequest__Init()
6377 {
6378 ::IceInternal::factoryTable->removeObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId());
6379 }
6380};
6381
6382static __F__Ehr__RemovePermissionRequest__Init __F__Ehr__RemovePermissionRequest__i;
6383
6384#ifdef __APPLE__
6385extern "C" { void __F__Ehr__RemovePermissionRequest__initializer() {} }
6386#endif
6387
6388void
6389Ehr::__patch__RemovePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
6390{
6391 ::Ehr::RemovePermissionRequestPtr* p = static_cast< ::Ehr::RemovePermissionRequestPtr*>(__addr);
6392 assert(p);
6393 *p = ::Ehr::RemovePermissionRequestPtr::dynamicCast(v);
6394 if(v && !*p)
6395 {
6396 IceInternal::Ex::throwUOE(::Ehr::RemovePermissionRequest::ice_staticId(), v->ice_id());
6397 }
6398}
6399
6400bool
6401Ehr::operator==(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
6402{
6403 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
6404}
6405
6406bool
6407Ehr::operator<(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
6408{
6409 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
6410}
6411
6412::Ice::ObjectPtr
6413Ehr::Provider::ice_clone() const
6414{
6415 throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
6416 return 0; // to avoid a warning with some compilers
6417}
6418
6419static const ::std::string __Ehr__Provider_ids[2] =
6420{
6421 "::Ehr::Provider",
6422 "::Ice::Object"
6423};
6424
6425bool
6426Ehr::Provider::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
6427{
6428 return ::std::binary_search(__Ehr__Provider_ids, __Ehr__Provider_ids + 2, _s);
6429}
6430
6431::std::vector< ::std::string>
6432Ehr::Provider::ice_ids(const ::Ice::Current&) const
6433{
6434 return ::std::vector< ::std::string>(&__Ehr__Provider_ids[0], &__Ehr__Provider_ids[2]);
6435}
6436
6437const ::std::string&
6438Ehr::Provider::ice_id(const ::Ice::Current&) const
6439{
6440 return __Ehr__Provider_ids[0];
6441}
6442
6443const ::std::string&
6444Ehr::Provider::ice_staticId()
6445{
6446 return __Ehr__Provider_ids[0];
6447}
6448
6449::Ice::DispatchStatus
6450Ehr::Provider::___createPrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6451{
6452 __checkMode(::Ice::Normal, __current.mode);
6453 ::IceInternal::BasicStream* __is = __inS.is();
6454 __is->startReadEncaps();
6455 ::Ehr::CreatePrescriptionRequestPtr request;
6456 ::Ehr::Signature requestorSignature;
6457 ::Ehr::Signature ownerSignature;
6458 __is->read(::Ehr::__patch__CreatePrescriptionRequestPtr, &request);
6459 requestorSignature.__read(__is);
6460 ownerSignature.__read(__is);
6461 __is->readPendingObjects();
6462 __is->endReadEncaps();
6463 ::IceInternal::BasicStream* __os = __inS.os();
6464 try
6465 {
6466 createPrescription(request, requestorSignature, ownerSignature, __current);
6467 }
6468 catch(const ::Ehr::EhrException& __ex)
6469 {
6470 __os->write(__ex);
6471 return ::Ice::DispatchUserException;
6472 }
6473 return ::Ice::DispatchOK;
6474}
6475
6476::Ice::DispatchStatus
6477Ehr::Provider::___consumePrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6478{
6479 __checkMode(::Ice::Normal, __current.mode);
6480 ::IceInternal::BasicStream* __is = __inS.is();
6481 __is->startReadEncaps();
6482 ::Ehr::ConsumePrescriptionRequestPtr request;
6483 ::Ehr::Signature requestorSignature;
6484 ::Ehr::Signature ownerSignature;
6485 __is->read(::Ehr::__patch__ConsumePrescriptionRequestPtr, &request);
6486 requestorSignature.__read(__is);
6487 ownerSignature.__read(__is);
6488 __is->readPendingObjects();
6489 __is->endReadEncaps();
6490 ::IceInternal::BasicStream* __os = __inS.os();
6491 try
6492 {
6493 consumePrescription(request, requestorSignature, ownerSignature, __current);
6494 }
6495 catch(const ::Ehr::EhrException& __ex)
6496 {
6497 __os->write(__ex);
6498 return ::Ice::DispatchUserException;
6499 }
6500 return ::Ice::DispatchOK;
6501}
6502
6503::Ice::DispatchStatus
6504Ehr::Provider::___listDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6505{
6506 __checkMode(::Ice::Normal, __current.mode);
6507 ::IceInternal::BasicStream* __is = __inS.is();
6508 __is->startReadEncaps();
6509 ::Ehr::ListDocumentsRequestPtr request;
6510 ::Ehr::Signature requestorSignature;
6511 ::Ehr::Signature ownerSignature;
6512 __is->read(::Ehr::__patch__ListDocumentsRequestPtr, &request);
6513 requestorSignature.__read(__is);
6514 ownerSignature.__read(__is);
6515 __is->readPendingObjects();
6516 __is->endReadEncaps();
6517 ::IceInternal::BasicStream* __os = __inS.os();
6518 try
6519 {
6520 ::Ehr::DocumentList __ret = listDocuments(request, requestorSignature, ownerSignature, __current);
6521 if(__ret.size() == 0)
6522 {
6523 __os->writeSize(0);
6524 }
6525 else
6526 {
6527 ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
6528 }
6529 }
6530 catch(const ::Ehr::EhrException& __ex)
6531 {
6532 __os->write(__ex);
6533 return ::Ice::DispatchUserException;
6534 }
6535 return ::Ice::DispatchOK;
6536}
6537
6538::Ice::DispatchStatus
6539Ehr::Provider::___findDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6540{
6541 __checkMode(::Ice::Normal, __current.mode);
6542 ::IceInternal::BasicStream* __is = __inS.is();
6543 __is->startReadEncaps();
6544 ::Ehr::FindDocumentsRequestPtr request;
6545 ::Ehr::Signature requestorSignature;
6546 ::Ehr::Signature ownerSignature;
6547 __is->read(::Ehr::__patch__FindDocumentsRequestPtr, &request);
6548 requestorSignature.__read(__is);
6549 ownerSignature.__read(__is);
6550 __is->readPendingObjects();
6551 __is->endReadEncaps();
6552 ::IceInternal::BasicStream* __os = __inS.os();
6553 try
6554 {
6555 ::Ehr::DocumentList __ret = findDocuments(request, requestorSignature, ownerSignature, __current);
6556 if(__ret.size() == 0)
6557 {
6558 __os->writeSize(0);
6559 }
6560 else
6561 {
6562 ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
6563 }
6564 }
6565 catch(const ::Ehr::EhrException& __ex)
6566 {
6567 __os->write(__ex);
6568 return ::Ice::DispatchUserException;
6569 }
6570 return ::Ice::DispatchOK;
6571}
6572
6573::Ice::DispatchStatus
6574Ehr::Provider::___setDefaultAccess(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6575{
6576 __checkMode(::Ice::Normal, __current.mode);
6577 ::IceInternal::BasicStream* __is = __inS.is();
6578 __is->startReadEncaps();
6579 ::Ehr::SetDefaultAccessRequestPtr request;
6580 ::Ehr::Signature requestorSignature;
6581 __is->read(::Ehr::__patch__SetDefaultAccessRequestPtr, &request);
6582 requestorSignature.__read(__is);
6583 __is->readPendingObjects();
6584 __is->endReadEncaps();
6585 ::IceInternal::BasicStream* __os = __inS.os();
6586 try
6587 {
6588 setDefaultAccess(request, requestorSignature, __current);
6589 }
6590 catch(const ::Ehr::EhrException& __ex)
6591 {
6592 __os->write(__ex);
6593 return ::Ice::DispatchUserException;
6594 }
6595 return ::Ice::DispatchOK;
6596}
6597
6598::Ice::DispatchStatus
6599Ehr::Provider::___createPermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6600{
6601 __checkMode(::Ice::Normal, __current.mode);
6602 ::IceInternal::BasicStream* __is = __inS.is();
6603 __is->startReadEncaps();
6604 ::Ehr::CreatePermissionRequestPtr request;
6605 ::Ehr::Signature requestorSignature;
6606 __is->read(::Ehr::__patch__CreatePermissionRequestPtr, &request);
6607 requestorSignature.__read(__is);
6608 __is->readPendingObjects();
6609 __is->endReadEncaps();
6610 ::IceInternal::BasicStream* __os = __inS.os();
6611 try
6612 {
6613 createPermission(request, requestorSignature, __current);
6614 }
6615 catch(const ::Ehr::EhrException& __ex)
6616 {
6617 __os->write(__ex);
6618 return ::Ice::DispatchUserException;
6619 }
6620 return ::Ice::DispatchOK;
6621}
6622
6623::Ice::DispatchStatus
6624Ehr::Provider::___listPermissions(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6625{
6626 __checkMode(::Ice::Normal, __current.mode);
6627 ::IceInternal::BasicStream* __is = __inS.is();
6628 __is->startReadEncaps();
6629 ::Ehr::ListPermissionsRequestPtr request;
6630 ::Ehr::Signature requestorSignature;
6631 __is->read(::Ehr::__patch__ListPermissionsRequestPtr, &request);
6632 requestorSignature.__read(__is);
6633 __is->readPendingObjects();
6634 __is->endReadEncaps();
6635 ::IceInternal::BasicStream* __os = __inS.os();
6636 try
6637 {
6638 ::Ehr::Permissions __ret = listPermissions(request, requestorSignature, __current);
6639 __ret.__write(__os);
6640 }
6641 catch(const ::Ehr::EhrException& __ex)
6642 {
6643 __os->write(__ex);
6644 return ::Ice::DispatchUserException;
6645 }
6646 return ::Ice::DispatchOK;
6647}
6648
6649::Ice::DispatchStatus
6650Ehr::Provider::___removePermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
6651{
6652 __checkMode(::Ice::Normal, __current.mode);
6653 ::IceInternal::BasicStream* __is = __inS.is();
6654 __is->startReadEncaps();
6655 ::Ehr::RemovePermissionRequestPtr request;
6656 ::Ehr::Signature requestorSignature;
6657 __is->read(::Ehr::__patch__RemovePermissionRequestPtr, &request);
6658 requestorSignature.__read(__is);
6659 __is->readPendingObjects();
6660 __is->endReadEncaps();
6661 ::IceInternal::BasicStream* __os = __inS.os();
6662 try
6663 {
6664 removePermission(request, requestorSignature, __current);
6665 }
6666 catch(const ::Ehr::EhrException& __ex)
6667 {
6668 __os->write(__ex);
6669 return ::Ice::DispatchUserException;
6670 }
6671 return ::Ice::DispatchOK;
6672}
6673
6674static ::std::string __Ehr__Provider_all[] =
6675{
6676 "consumePrescription",
6677 "createPermission",
6678 "createPrescription",
6679 "findDocuments",
6680 "ice_id",
6681 "ice_ids",
6682 "ice_isA",
6683 "ice_ping",
6684 "listDocuments",
6685 "listPermissions",
6686 "removePermission",
6687 "setDefaultAccess"
6688};
6689
6690::Ice::DispatchStatus
6691Ehr::Provider::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
6692{
6693 ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Ehr__Provider_all, __Ehr__Provider_all + 12, current.operation);
6694 if(r.first == r.second)
6695 {
6696 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
6697 }
6698
6699 switch(r.first - __Ehr__Provider_all)
6700 {
6701 case 0:
6702 {
6703 return ___consumePrescription(in, current);
6704 }
6705 case 1:
6706 {
6707 return ___createPermission(in, current);
6708 }
6709 case 2:
6710 {
6711 return ___createPrescription(in, current);
6712 }
6713 case 3:
6714 {
6715 return ___findDocuments(in, current);
6716 }
6717 case 4:
6718 {
6719 return ___ice_id(in, current);
6720 }
6721 case 5:
6722 {
6723 return ___ice_ids(in, current);
6724 }
6725 case 6:
6726 {
6727 return ___ice_isA(in, current);
6728 }
6729 case 7:
6730 {
6731 return ___ice_ping(in, current);
6732 }
6733 case 8:
6734 {
6735 return ___listDocuments(in, current);
6736 }
6737 case 9:
6738 {
6739 return ___listPermissions(in, current);
6740 }
6741 case 10:
6742 {
6743 return ___removePermission(in, current);
6744 }
6745 case 11:
6746 {
6747 return ___setDefaultAccess(in, current);
6748 }
6749 }
6750
6751 assert(false);
6752 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
6753}
6754
6755void
6756Ehr::Provider::__write(::IceInternal::BasicStream* __os) const
6757{
6758 __os->writeTypeId(ice_staticId());
6759 __os->startWriteSlice();
6760 __os->endWriteSlice();
6761#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6762 Object::__write(__os);
6763#else
6764 ::Ice::Object::__write(__os);
6765#endif
6766}
6767
6768void
6769Ehr::Provider::__read(::IceInternal::BasicStream* __is, bool __rid)
6770{
6771 if(__rid)
6772 {
6773 ::std::string myId;
6774 __is->readTypeId(myId);
6775 }
6776 __is->startReadSlice();
6777 __is->endReadSlice();
6778#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6779 Object::__read(__is, true);
6780#else
6781 ::Ice::Object::__read(__is, true);
6782#endif
6783}
6784
6785void
6786Ehr::Provider::__write(const ::Ice::OutputStreamPtr& __outS) const
6787{
6788 __outS->writeTypeId(ice_staticId());
6789 __outS->startSlice();
6790 __outS->endSlice();
6791#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6792 Object::__write(__outS);
6793#else
6794 ::Ice::Object::__write(__outS);
6795#endif
6796}
6797
6798void
6799Ehr::Provider::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
6800{
6801 if(__rid)
6802 {
6803 __inS->readTypeId();
6804 }
6805 __inS->startSlice();
6806 __inS->endSlice();
6807#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
6808 Object::__read(__inS, true);
6809#else
6810 ::Ice::Object::__read(__inS, true);
6811#endif
6812}
6813
6814void
6815Ehr::__patch__ProviderPtr(void* __addr, ::Ice::ObjectPtr& v)
6816{
6817 ::Ehr::ProviderPtr* p = static_cast< ::Ehr::ProviderPtr*>(__addr);
6818 assert(p);
6819 *p = ::Ehr::ProviderPtr::dynamicCast(v);
6820 if(v && !*p)
6821 {
6822 IceInternal::Ex::throwUOE(::Ehr::Provider::ice_staticId(), v->ice_id());
6823 }
6824}
6825
6826bool
6827Ehr::operator==(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
6828{
6829 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
6830}
6831
6832bool
6833Ehr::operator<(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
6834{
6835 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
6836}
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-11 20:44:58 +0000