1 files changed, 6836 insertions, 0 deletions

diff --git a/task1/ehr.cpp b/task1/ehr.cpp
new file mode 100644
index 0000000..29b45e9
--- /dev/null
+++ b/task1/ehr.cpp
@@ -0,0 +1,6836 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+// Ice version 3.3.1
+// Generated from file `ehr.ice'
+
+#include <ehr.h>
+#include <Ice/LocalException.h>
+#include <Ice/ObjectFactory.h>
+#include <Ice/BasicStream.h>
+#include <Ice/Stream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/ScopedArray.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION / 100 != 303
+#       error Ice version mismatch!
+#   endif
+#   if ICE_INT_VERSION % 100 > 50
+#       error Beta header file detected
+#   endif
+#   if ICE_INT_VERSION % 100 < 1
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+static const ::std::string __Ehr__Provider__createPrescription_name = "createPrescription";
+
+static const ::std::string __Ehr__Provider__consumePrescription_name = "consumePrescription";
+
+static const ::std::string __Ehr__Provider__listDocuments_name = "listDocuments";
+
+static const ::std::string __Ehr__Provider__findDocuments_name = "findDocuments";
+
+static const ::std::string __Ehr__Provider__setDefaultAccess_name = "setDefaultAccess";
+
+static const ::std::string __Ehr__Provider__createPermission_name = "createPermission";
+
+static const ::std::string __Ehr__Provider__listPermissions_name = "listPermissions";
+
+static const ::std::string __Ehr__Provider__removePermission_name = "removePermission";
+
+::Ice::Object* IceInternal::upCast(::Ehr::Document* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Document* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::Prescription* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Prescription* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::ConsumedPrescription* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumedPrescription* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::Request* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Request* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::ThirdPartyRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ThirdPartyRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::CreatePrescriptionRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePrescriptionRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::ConsumePrescriptionRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumePrescriptionRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::ListDocumentsRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListDocumentsRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::FindDocumentsRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::FindDocumentsRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::CreatePermissionRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePermissionRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::SetDefaultAccessRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::SetDefaultAccessRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::ListPermissionsRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListPermissionsRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::RemovePermissionRequest* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::RemovePermissionRequest* p) { return p; }
+
+::Ice::Object* IceInternal::upCast(::Ehr::Provider* p) { return p; }
+::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Provider* p) { return p; }
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Document;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeDocumentPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readDocumentPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Document;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__DocumentPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::PrescriptionPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Prescription;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writePrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Prescription;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writePrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__PrescriptionPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumedPrescriptionPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ConsumedPrescription;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeConsumedPrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readConsumedPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ConsumedPrescription;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeConsumedPrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readConsumedPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumedPrescriptionPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Request;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Request;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ThirdPartyRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ThirdPartyRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeThirdPartyRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readThirdPartyRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ThirdPartyRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeThirdPartyRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readThirdPartyRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ThirdPartyRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePrescriptionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeCreatePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readCreatePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeCreatePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readCreatePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePrescriptionRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumePrescriptionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeConsumePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readConsumePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeConsumePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readConsumePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumePrescriptionRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListDocumentsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ListDocumentsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeListDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readListDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ListDocumentsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeListDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readListDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListDocumentsRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::FindDocumentsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::FindDocumentsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeFindDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readFindDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::FindDocumentsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeFindDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readFindDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__FindDocumentsRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePermissionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::CreatePermissionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeCreatePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readCreatePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::CreatePermissionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeCreatePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readCreatePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePermissionRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::SetDefaultAccessRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeSetDefaultAccessRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readSetDefaultAccessRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeSetDefaultAccessRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readSetDefaultAccessRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__SetDefaultAccessRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListPermissionsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ListPermissionsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeListPermissionsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readListPermissionsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::ListPermissionsRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeListPermissionsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readListPermissionsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListPermissionsRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RemovePermissionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::RemovePermissionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeRemovePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readRemovePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::RemovePermissionRequest;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeRemovePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readRemovePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RemovePermissionRequestPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ProviderPrx& v)
+{
+    ::Ice::ObjectPrx proxy;
+    __is->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Provider;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeProviderPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPrx& v)
+{
+    __outS->writeProxy(v);
+}
+
+void
+Ehr::ice_readProviderPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPrx& v)
+{
+    ::Ice::ObjectPrx proxy = __inS->readProxy();
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::Ehr::Provider;
+        v->__copyFrom(proxy);
+    }
+}
+
+void
+Ehr::ice_writeProvider(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPtr& v)
+{
+    __outS->writeObject(v);
+}
+
+void
+Ehr::ice_readProvider(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPtr& __v)
+{
+    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ProviderPtr, &__v);
+    __inS->readObject(__cb);
+}
+
+Ehr::EhrException::EhrException(const ::std::string& __ice_what) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    UserException(),
+#else
+    ::Ice::UserException(),
+#endif
+    what(__ice_what)
+{
+}
+
+Ehr::EhrException::~EhrException() throw()
+{
+}
+
+static const char* __Ehr__EhrException_name = "Ehr::EhrException";
+
+::std::string
+Ehr::EhrException::ice_name() const
+{
+    return __Ehr__EhrException_name;
+}
+
+::Ice::Exception*
+Ehr::EhrException::ice_clone() const
+{
+    return new EhrException(*this);
+}
+
+void
+Ehr::EhrException::ice_throw() const
+{
+    throw *this;
+}
+
+void
+Ehr::EhrException::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(::std::string("::Ehr::EhrException"), false);
+    __os->startWriteSlice();
+    __os->write(what);
+    __os->endWriteSlice();
+}
+
+void
+Ehr::EhrException::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->read(myId, false);
+    }
+    __is->startReadSlice();
+    __is->read(what);
+    __is->endReadSlice();
+}
+
+void
+Ehr::EhrException::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(::std::string("::Ehr::EhrException"));
+    __outS->startSlice();
+    __outS->writeString(what);
+    __outS->endSlice();
+}
+
+void
+Ehr::EhrException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readString();
+    }
+    __inS->startSlice();
+    what = __inS->readString();
+    __inS->endSlice();
+}
+
+struct __F__Ehr__EhrException : public ::IceInternal::UserExceptionFactory
+{
+    virtual void
+    createAndThrow()
+    {
+        throw ::Ehr::EhrException();
+    }
+};
+
+static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__EhrException__Ptr = new __F__Ehr__EhrException;
+
+const ::IceInternal::UserExceptionFactoryPtr&
+Ehr::EhrException::ice_factory()
+{
+    return __F__Ehr__EhrException__Ptr;
+}
+
+class __F__Ehr__EhrException__Init
+{
+public:
+
+    __F__Ehr__EhrException__Init()
+    {
+        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::EhrException", ::Ehr::EhrException::ice_factory());
+    }
+
+    ~__F__Ehr__EhrException__Init()
+    {
+        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::EhrException");
+    }
+};
+
+static __F__Ehr__EhrException__Init __F__Ehr__EhrException__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__EhrException__initializer() {} }
+#endif
+
+Ehr::InvalidRequestException::InvalidRequestException(const ::std::string& __ice_what) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException(__ice_what)
+#else
+    ::Ehr::EhrException(__ice_what)
+#endif
+{
+}
+
+Ehr::InvalidRequestException::~InvalidRequestException() throw()
+{
+}
+
+static const char* __Ehr__InvalidRequestException_name = "Ehr::InvalidRequestException";
+
+::std::string
+Ehr::InvalidRequestException::ice_name() const
+{
+    return __Ehr__InvalidRequestException_name;
+}
+
+::Ice::Exception*
+Ehr::InvalidRequestException::ice_clone() const
+{
+    return new InvalidRequestException(*this);
+}
+
+void
+Ehr::InvalidRequestException::ice_throw() const
+{
+    throw *this;
+}
+
+void
+Ehr::InvalidRequestException::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(::std::string("::Ehr::InvalidRequestException"), false);
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__os);
+#else
+    ::Ehr::EhrException::__write(__os);
+#endif
+}
+
+void
+Ehr::InvalidRequestException::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->read(myId, false);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__is, true);
+#else
+    ::Ehr::EhrException::__read(__is, true);
+#endif
+}
+
+void
+Ehr::InvalidRequestException::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(::std::string("::Ehr::InvalidRequestException"));
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__outS);
+#else
+    ::Ehr::EhrException::__write(__outS);
+#endif
+}
+
+void
+Ehr::InvalidRequestException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readString();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__inS, true);
+#else
+    ::Ehr::EhrException::__read(__inS, true);
+#endif
+}
+
+struct __F__Ehr__InvalidRequestException : public ::IceInternal::UserExceptionFactory
+{
+    virtual void
+    createAndThrow()
+    {
+        throw ::Ehr::InvalidRequestException();
+    }
+};
+
+static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidRequestException__Ptr = new __F__Ehr__InvalidRequestException;
+
+const ::IceInternal::UserExceptionFactoryPtr&
+Ehr::InvalidRequestException::ice_factory()
+{
+    return __F__Ehr__InvalidRequestException__Ptr;
+}
+
+class __F__Ehr__InvalidRequestException__Init
+{
+public:
+
+    __F__Ehr__InvalidRequestException__Init()
+    {
+        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidRequestException", ::Ehr::InvalidRequestException::ice_factory());
+    }
+
+    ~__F__Ehr__InvalidRequestException__Init()
+    {
+        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidRequestException");
+    }
+};
+
+static __F__Ehr__InvalidRequestException__Init __F__Ehr__InvalidRequestException__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__InvalidRequestException__initializer() {} }
+#endif
+
+Ehr::InvalidAccountException::InvalidAccountException(const ::std::string& __ice_what) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    InvalidRequestException(__ice_what)
+#else
+    ::Ehr::InvalidRequestException(__ice_what)
+#endif
+{
+}
+
+Ehr::InvalidAccountException::~InvalidAccountException() throw()
+{
+}
+
+static const char* __Ehr__InvalidAccountException_name = "Ehr::InvalidAccountException";
+
+::std::string
+Ehr::InvalidAccountException::ice_name() const
+{
+    return __Ehr__InvalidAccountException_name;
+}
+
+::Ice::Exception*
+Ehr::InvalidAccountException::ice_clone() const
+{
+    return new InvalidAccountException(*this);
+}
+
+void
+Ehr::InvalidAccountException::ice_throw() const
+{
+    throw *this;
+}
+
+void
+Ehr::InvalidAccountException::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(::std::string("::Ehr::InvalidAccountException"), false);
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    InvalidRequestException::__write(__os);
+#else
+    ::Ehr::InvalidRequestException::__write(__os);
+#endif
+}
+
+void
+Ehr::InvalidAccountException::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->read(myId, false);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    InvalidRequestException::__read(__is, true);
+#else
+    ::Ehr::InvalidRequestException::__read(__is, true);
+#endif
+}
+
+void
+Ehr::InvalidAccountException::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(::std::string("::Ehr::InvalidAccountException"));
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    InvalidRequestException::__write(__outS);
+#else
+    ::Ehr::InvalidRequestException::__write(__outS);
+#endif
+}
+
+void
+Ehr::InvalidAccountException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readString();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    InvalidRequestException::__read(__inS, true);
+#else
+    ::Ehr::InvalidRequestException::__read(__inS, true);
+#endif
+}
+
+struct __F__Ehr__InvalidAccountException : public ::IceInternal::UserExceptionFactory
+{
+    virtual void
+    createAndThrow()
+    {
+        throw ::Ehr::InvalidAccountException();
+    }
+};
+
+static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidAccountException__Ptr = new __F__Ehr__InvalidAccountException;
+
+const ::IceInternal::UserExceptionFactoryPtr&
+Ehr::InvalidAccountException::ice_factory()
+{
+    return __F__Ehr__InvalidAccountException__Ptr;
+}
+
+class __F__Ehr__InvalidAccountException__Init
+{
+public:
+
+    __F__Ehr__InvalidAccountException__Init()
+    {
+        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidAccountException", ::Ehr::InvalidAccountException::ice_factory());
+    }
+
+    ~__F__Ehr__InvalidAccountException__Init()
+    {
+        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidAccountException");
+    }
+};
+
+static __F__Ehr__InvalidAccountException__Init __F__Ehr__InvalidAccountException__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__InvalidAccountException__initializer() {} }
+#endif
+
+Ehr::SignatureException::SignatureException(const ::std::string& __ice_what) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException(__ice_what)
+#else
+    ::Ehr::EhrException(__ice_what)
+#endif
+{
+}
+
+Ehr::SignatureException::~SignatureException() throw()
+{
+}
+
+static const char* __Ehr__SignatureException_name = "Ehr::SignatureException";
+
+::std::string
+Ehr::SignatureException::ice_name() const
+{
+    return __Ehr__SignatureException_name;
+}
+
+::Ice::Exception*
+Ehr::SignatureException::ice_clone() const
+{
+    return new SignatureException(*this);
+}
+
+void
+Ehr::SignatureException::ice_throw() const
+{
+    throw *this;
+}
+
+void
+Ehr::SignatureException::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(::std::string("::Ehr::SignatureException"), false);
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__os);
+#else
+    ::Ehr::EhrException::__write(__os);
+#endif
+}
+
+void
+Ehr::SignatureException::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->read(myId, false);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__is, true);
+#else
+    ::Ehr::EhrException::__read(__is, true);
+#endif
+}
+
+void
+Ehr::SignatureException::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(::std::string("::Ehr::SignatureException"));
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__outS);
+#else
+    ::Ehr::EhrException::__write(__outS);
+#endif
+}
+
+void
+Ehr::SignatureException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readString();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__inS, true);
+#else
+    ::Ehr::EhrException::__read(__inS, true);
+#endif
+}
+
+struct __F__Ehr__SignatureException : public ::IceInternal::UserExceptionFactory
+{
+    virtual void
+    createAndThrow()
+    {
+        throw ::Ehr::SignatureException();
+    }
+};
+
+static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__SignatureException__Ptr = new __F__Ehr__SignatureException;
+
+const ::IceInternal::UserExceptionFactoryPtr&
+Ehr::SignatureException::ice_factory()
+{
+    return __F__Ehr__SignatureException__Ptr;
+}
+
+class __F__Ehr__SignatureException__Init
+{
+public:
+
+    __F__Ehr__SignatureException__Init()
+    {
+        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::SignatureException", ::Ehr::SignatureException::ice_factory());
+    }
+
+    ~__F__Ehr__SignatureException__Init()
+    {
+        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::SignatureException");
+    }
+};
+
+static __F__Ehr__SignatureException__Init __F__Ehr__SignatureException__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__SignatureException__initializer() {} }
+#endif
+
+Ehr::PermissionDeniedException::PermissionDeniedException(const ::std::string& __ice_what) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException(__ice_what)
+#else
+    ::Ehr::EhrException(__ice_what)
+#endif
+{
+}
+
+Ehr::PermissionDeniedException::~PermissionDeniedException() throw()
+{
+}
+
+static const char* __Ehr__PermissionDeniedException_name = "Ehr::PermissionDeniedException";
+
+::std::string
+Ehr::PermissionDeniedException::ice_name() const
+{
+    return __Ehr__PermissionDeniedException_name;
+}
+
+::Ice::Exception*
+Ehr::PermissionDeniedException::ice_clone() const
+{
+    return new PermissionDeniedException(*this);
+}
+
+void
+Ehr::PermissionDeniedException::ice_throw() const
+{
+    throw *this;
+}
+
+void
+Ehr::PermissionDeniedException::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(::std::string("::Ehr::PermissionDeniedException"), false);
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__os);
+#else
+    ::Ehr::EhrException::__write(__os);
+#endif
+}
+
+void
+Ehr::PermissionDeniedException::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->read(myId, false);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__is, true);
+#else
+    ::Ehr::EhrException::__read(__is, true);
+#endif
+}
+
+void
+Ehr::PermissionDeniedException::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(::std::string("::Ehr::PermissionDeniedException"));
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__write(__outS);
+#else
+    ::Ehr::EhrException::__write(__outS);
+#endif
+}
+
+void
+Ehr::PermissionDeniedException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readString();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    EhrException::__read(__inS, true);
+#else
+    ::Ehr::EhrException::__read(__inS, true);
+#endif
+}
+
+struct __F__Ehr__PermissionDeniedException : public ::IceInternal::UserExceptionFactory
+{
+    virtual void
+    createAndThrow()
+    {
+        throw ::Ehr::PermissionDeniedException();
+    }
+};
+
+static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__PermissionDeniedException__Ptr = new __F__Ehr__PermissionDeniedException;
+
+const ::IceInternal::UserExceptionFactoryPtr&
+Ehr::PermissionDeniedException::ice_factory()
+{
+    return __F__Ehr__PermissionDeniedException__Ptr;
+}
+
+class __F__Ehr__PermissionDeniedException__Init
+{
+public:
+
+    __F__Ehr__PermissionDeniedException__Init()
+    {
+        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::PermissionDeniedException", ::Ehr::PermissionDeniedException::ice_factory());
+    }
+
+    ~__F__Ehr__PermissionDeniedException__Init()
+    {
+        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::PermissionDeniedException");
+    }
+};
+
+static __F__Ehr__PermissionDeniedException__Init __F__Ehr__PermissionDeniedException__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__PermissionDeniedException__initializer() {} }
+#endif
+
+bool
+Ehr::AccountIdentifier::operator==(const AccountIdentifier& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(user != __rhs.user)
+    {
+        return false;
+    }
+    if(provider != __rhs.provider)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::AccountIdentifier::operator<(const AccountIdentifier& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(user < __rhs.user)
+    {
+        return true;
+    }
+    else if(__rhs.user < user)
+    {
+        return false;
+    }
+    if(provider < __rhs.provider)
+    {
+        return true;
+    }
+    else if(__rhs.provider < provider)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::AccountIdentifier::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(user);
+    __os->write(provider);
+}
+
+void
+Ehr::AccountIdentifier::__read(::IceInternal::BasicStream* __is)
+{
+    __is->read(user);
+    __is->read(provider);
+}
+
+void
+Ehr::AccountIdentifier::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeString(user);
+    __outS->writeString(provider);
+}
+
+void
+Ehr::AccountIdentifier::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    user = __inS->readString();
+    provider = __inS->readString();
+}
+
+void
+Ehr::ice_writeAccountIdentifier(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccountIdentifier& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readAccountIdentifier(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccountIdentifier& __v)
+{
+    __v.ice_read(__inS);
+}
+
+void
+Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::DocumentType v)
+{
+    __os->write(static_cast< ::Ice::Byte>(v), 3);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentType& v)
+{
+    ::Ice::Byte val;
+    __is->read(val, 3);
+    v = static_cast< ::Ehr::DocumentType>(val);
+}
+
+void
+Ehr::ice_writeDocumentType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::DocumentType v)
+{
+    if(static_cast<int>(v) >= 3)
+    {
+        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
+    }
+    __outS->writeByte(static_cast< ::Ice::Byte>(v));
+}
+
+void
+Ehr::ice_readDocumentType(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentType& v)
+{
+    ::Ice::Byte val = __inS->readByte();
+    if(val > 3)
+    {
+        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
+    }
+    v = static_cast< ::Ehr::DocumentType>(val);
+}
+
+bool
+Ehr::Signature::operator==(const Signature& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(data != __rhs.data)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::Signature::operator<(const Signature& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(data < __rhs.data)
+    {
+        return true;
+    }
+    else if(__rhs.data < data)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::Signature::__write(::IceInternal::BasicStream* __os) const
+{
+    if(data.size() == 0)
+    {
+        __os->writeSize(0);
+    }
+    else
+    {
+        __os->write(&data[0], &data[0] + data.size());
+    }
+}
+
+void
+Ehr::Signature::__read(::IceInternal::BasicStream* __is)
+{
+    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___data;
+    __is->read(___data);
+    ::std::vector< ::Ice::Byte>(___data.first, ___data.second).swap(data);
+}
+
+void
+Ehr::Signature::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeByteSeq(data);
+}
+
+void
+Ehr::Signature::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    data = __inS->readByteSeq();
+}
+
+void
+Ehr::ice_writeSignature(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Signature& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readSignature(const ::Ice::InputStreamPtr& __inS, ::Ehr::Signature& __v)
+{
+    __v.ice_read(__inS);
+}
+
+bool
+Ehr::Timestamp::operator==(const Timestamp& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(msecs != __rhs.msecs)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::Timestamp::operator<(const Timestamp& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(msecs < __rhs.msecs)
+    {
+        return true;
+    }
+    else if(__rhs.msecs < msecs)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::Timestamp::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(msecs);
+}
+
+void
+Ehr::Timestamp::__read(::IceInternal::BasicStream* __is)
+{
+    __is->read(msecs);
+}
+
+void
+Ehr::Timestamp::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeLong(msecs);
+}
+
+void
+Ehr::Timestamp::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    msecs = __inS->readLong();
+}
+
+void
+Ehr::ice_writeTimestamp(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Timestamp& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readTimestamp(const ::Ice::InputStreamPtr& __inS, ::Ehr::Timestamp& __v)
+{
+    __v.ice_read(__inS);
+}
+
+bool
+Ehr::Date::operator==(const Date& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(day != __rhs.day)
+    {
+        return false;
+    }
+    if(month != __rhs.month)
+    {
+        return false;
+    }
+    if(year != __rhs.year)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::Date::operator<(const Date& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(day < __rhs.day)
+    {
+        return true;
+    }
+    else if(__rhs.day < day)
+    {
+        return false;
+    }
+    if(month < __rhs.month)
+    {
+        return true;
+    }
+    else if(__rhs.month < month)
+    {
+        return false;
+    }
+    if(year < __rhs.year)
+    {
+        return true;
+    }
+    else if(__rhs.year < year)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::Date::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(day);
+    __os->write(month);
+    __os->write(year);
+}
+
+void
+Ehr::Date::__read(::IceInternal::BasicStream* __is)
+{
+    __is->read(day);
+    __is->read(month);
+    __is->read(year);
+}
+
+void
+Ehr::Date::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeByte(day);
+    __outS->writeByte(month);
+    __outS->writeShort(year);
+}
+
+void
+Ehr::Date::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    day = __inS->readByte();
+    month = __inS->readByte();
+    year = __inS->readShort();
+}
+
+void
+Ehr::ice_writeDate(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Date& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readDate(const ::Ice::InputStreamPtr& __inS, ::Ehr::Date& __v)
+{
+    __v.ice_read(__inS);
+}
+
+void
+Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::AccessType v)
+{
+    __os->write(static_cast< ::Ice::Byte>(v), 2);
+}
+
+void
+Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::AccessType& v)
+{
+    ::Ice::Byte val;
+    __is->read(val, 2);
+    v = static_cast< ::Ehr::AccessType>(val);
+}
+
+void
+Ehr::ice_writeAccessType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::AccessType v)
+{
+    if(static_cast<int>(v) >= 2)
+    {
+        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
+    }
+    __outS->writeByte(static_cast< ::Ice::Byte>(v));
+}
+
+void
+Ehr::ice_readAccessType(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessType& v)
+{
+    ::Ice::Byte val = __inS->readByte();
+    if(val > 2)
+    {
+        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
+    }
+    v = static_cast< ::Ehr::AccessType>(val);
+}
+
+bool
+Ehr::EncryptedDocument::operator==(const EncryptedDocument& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(encryptedKey != __rhs.encryptedKey)
+    {
+        return false;
+    }
+    if(initialVector != __rhs.initialVector)
+    {
+        return false;
+    }
+    if(encryptedData != __rhs.encryptedData)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::EncryptedDocument::operator<(const EncryptedDocument& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(encryptedKey < __rhs.encryptedKey)
+    {
+        return true;
+    }
+    else if(__rhs.encryptedKey < encryptedKey)
+    {
+        return false;
+    }
+    if(initialVector < __rhs.initialVector)
+    {
+        return true;
+    }
+    else if(__rhs.initialVector < initialVector)
+    {
+        return false;
+    }
+    if(encryptedData < __rhs.encryptedData)
+    {
+        return true;
+    }
+    else if(__rhs.encryptedData < encryptedData)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::EncryptedDocument::__write(::IceInternal::BasicStream* __os) const
+{
+    if(encryptedKey.size() == 0)
+    {
+        __os->writeSize(0);
+    }
+    else
+    {
+        __os->write(&encryptedKey[0], &encryptedKey[0] + encryptedKey.size());
+    }
+    if(initialVector.size() == 0)
+    {
+        __os->writeSize(0);
+    }
+    else
+    {
+        __os->write(&initialVector[0], &initialVector[0] + initialVector.size());
+    }
+    if(encryptedData.size() == 0)
+    {
+        __os->writeSize(0);
+    }
+    else
+    {
+        __os->write(&encryptedData[0], &encryptedData[0] + encryptedData.size());
+    }
+}
+
+void
+Ehr::EncryptedDocument::__read(::IceInternal::BasicStream* __is)
+{
+    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedKey;
+    __is->read(___encryptedKey);
+    ::std::vector< ::Ice::Byte>(___encryptedKey.first, ___encryptedKey.second).swap(encryptedKey);
+    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___initialVector;
+    __is->read(___initialVector);
+    ::std::vector< ::Ice::Byte>(___initialVector.first, ___initialVector.second).swap(initialVector);
+    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedData;
+    __is->read(___encryptedData);
+    ::std::vector< ::Ice::Byte>(___encryptedData.first, ___encryptedData.second).swap(encryptedData);
+}
+
+void
+Ehr::EncryptedDocument::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeByteSeq(encryptedKey);
+    __outS->writeByteSeq(initialVector);
+    __outS->writeByteSeq(encryptedData);
+}
+
+void
+Ehr::EncryptedDocument::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    encryptedKey = __inS->readByteSeq();
+    initialVector = __inS->readByteSeq();
+    encryptedData = __inS->readByteSeq();
+}
+
+void
+Ehr::ice_writeEncryptedDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::EncryptedDocument& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readEncryptedDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::EncryptedDocument& __v)
+{
+    __v.ice_read(__inS);
+}
+
+bool
+Ehr::DocumentListItem::operator==(const DocumentListItem& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(id != __rhs.id)
+    {
+        return false;
+    }
+    if(created != __rhs.created)
+    {
+        return false;
+    }
+    if(document != __rhs.document)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::DocumentListItem::operator<(const DocumentListItem& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(id < __rhs.id)
+    {
+        return true;
+    }
+    else if(__rhs.id < id)
+    {
+        return false;
+    }
+    if(created < __rhs.created)
+    {
+        return true;
+    }
+    else if(__rhs.created < created)
+    {
+        return false;
+    }
+    if(document < __rhs.document)
+    {
+        return true;
+    }
+    else if(__rhs.document < document)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::DocumentListItem::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(id);
+    created.__write(__os);
+    document.__write(__os);
+}
+
+void
+Ehr::DocumentListItem::__read(::IceInternal::BasicStream* __is)
+{
+    __is->read(id);
+    created.__read(__is);
+    document.__read(__is);
+}
+
+void
+Ehr::DocumentListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeLong(id);
+    ::Ehr::ice_writeTimestamp(__outS, created);
+    ::Ehr::ice_writeEncryptedDocument(__outS, document);
+}
+
+void
+Ehr::DocumentListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    id = __inS->readLong();
+    ::Ehr::ice_readTimestamp(__inS, created);
+    ::Ehr::ice_readEncryptedDocument(__inS, document);
+}
+
+void
+Ehr::ice_writeDocumentListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentListItem& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readDocumentListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentListItem& __v)
+{
+    __v.ice_read(__inS);
+}
+
+void
+Ehr::__writeDocumentList(::IceInternal::BasicStream* __os, const ::Ehr::DocumentListItem* begin, const ::Ehr::DocumentListItem* end)
+{
+    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
+    __os->writeSize(size);
+    for(int i = 0; i < size; ++i)
+    {
+        begin[i].__write(__os);
+    }
+}
+
+void
+Ehr::__readDocumentList(::IceInternal::BasicStream* __is, ::Ehr::DocumentList& v)
+{
+    ::Ice::Int sz;
+    __is->readSize(sz);
+    __is->startSeq(sz, 19);
+    v.resize(sz);
+    for(int i = 0; i < sz; ++i)
+    {
+        v[i].__read(__is);
+        __is->checkSeq();
+        __is->endElement();
+    }
+    __is->endSeq(sz);
+}
+
+void
+Ehr::ice_writeDocumentList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentList& v)
+{
+    __outS->writeSize(::Ice::Int(v.size()));
+    ::Ehr::DocumentList::const_iterator p;
+    for(p = v.begin(); p != v.end(); ++p)
+    {
+        ::Ehr::ice_writeDocumentListItem(__outS, (*p));
+    }
+}
+
+void
+Ehr::ice_readDocumentList(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentList& v)
+{
+    ::Ice::Int sz = __inS->readSize();
+    v.resize(sz);
+    for(int i = 0; i < sz; ++i)
+    {
+        ::Ehr::ice_readDocumentListItem(__inS, v[i]);
+    }
+}
+
+bool
+Ehr::AccessControlListItem::operator==(const AccessControlListItem& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(id != __rhs.id)
+    {
+        return false;
+    }
+    if(account != __rhs.account)
+    {
+        return false;
+    }
+    if(access != __rhs.access)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::AccessControlListItem::operator<(const AccessControlListItem& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(id < __rhs.id)
+    {
+        return true;
+    }
+    else if(__rhs.id < id)
+    {
+        return false;
+    }
+    if(account < __rhs.account)
+    {
+        return true;
+    }
+    else if(__rhs.account < account)
+    {
+        return false;
+    }
+    if(access < __rhs.access)
+    {
+        return true;
+    }
+    else if(__rhs.access < access)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::AccessControlListItem::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->write(id);
+    account.__write(__os);
+    ::Ehr::__write(__os, access);
+}
+
+void
+Ehr::AccessControlListItem::__read(::IceInternal::BasicStream* __is)
+{
+    __is->read(id);
+    account.__read(__is);
+    ::Ehr::__read(__is, access);
+}
+
+void
+Ehr::AccessControlListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeLong(id);
+    ::Ehr::ice_writeAccountIdentifier(__outS, account);
+    ::Ehr::ice_writeAccessType(__outS, access);
+}
+
+void
+Ehr::AccessControlListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    id = __inS->readLong();
+    ::Ehr::ice_readAccountIdentifier(__inS, account);
+    ::Ehr::ice_readAccessType(__inS, access);
+}
+
+void
+Ehr::ice_writeAccessControlListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlListItem& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readAccessControlListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlListItem& __v)
+{
+    __v.ice_read(__inS);
+}
+
+void
+Ehr::__writeAccessControlList(::IceInternal::BasicStream* __os, const ::Ehr::AccessControlListItem* begin, const ::Ehr::AccessControlListItem* end)
+{
+    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
+    __os->writeSize(size);
+    for(int i = 0; i < size; ++i)
+    {
+        begin[i].__write(__os);
+    }
+}
+
+void
+Ehr::__readAccessControlList(::IceInternal::BasicStream* __is, ::Ehr::AccessControlList& v)
+{
+    ::Ice::Int sz;
+    __is->readSize(sz);
+    __is->startSeq(sz, 11);
+    v.resize(sz);
+    for(int i = 0; i < sz; ++i)
+    {
+        v[i].__read(__is);
+        __is->checkSeq();
+        __is->endElement();
+    }
+    __is->endSeq(sz);
+}
+
+void
+Ehr::ice_writeAccessControlList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlList& v)
+{
+    __outS->writeSize(::Ice::Int(v.size()));
+    ::Ehr::AccessControlList::const_iterator p;
+    for(p = v.begin(); p != v.end(); ++p)
+    {
+        ::Ehr::ice_writeAccessControlListItem(__outS, (*p));
+    }
+}
+
+void
+Ehr::ice_readAccessControlList(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlList& v)
+{
+    ::Ice::Int sz = __inS->readSize();
+    v.resize(sz);
+    for(int i = 0; i < sz; ++i)
+    {
+        ::Ehr::ice_readAccessControlListItem(__inS, v[i]);
+    }
+}
+
+bool
+Ehr::Permissions::operator==(const Permissions& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return true;
+    }
+    if(defaultAccess != __rhs.defaultAccess)
+    {
+        return false;
+    }
+    if(acl != __rhs.acl)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool
+Ehr::Permissions::operator<(const Permissions& __rhs) const
+{
+    if(this == &__rhs)
+    {
+        return false;
+    }
+    if(defaultAccess < __rhs.defaultAccess)
+    {
+        return true;
+    }
+    else if(__rhs.defaultAccess < defaultAccess)
+    {
+        return false;
+    }
+    if(acl < __rhs.acl)
+    {
+        return true;
+    }
+    else if(__rhs.acl < acl)
+    {
+        return false;
+    }
+    return false;
+}
+
+void
+Ehr::Permissions::__write(::IceInternal::BasicStream* __os) const
+{
+    ::Ehr::__write(__os, defaultAccess);
+    if(acl.size() == 0)
+    {
+        __os->writeSize(0);
+    }
+    else
+    {
+        ::Ehr::__writeAccessControlList(__os, &acl[0], &acl[0] + acl.size());
+    }
+}
+
+void
+Ehr::Permissions::__read(::IceInternal::BasicStream* __is)
+{
+    ::Ehr::__read(__is, defaultAccess);
+    ::Ehr::__readAccessControlList(__is, acl);
+}
+
+void
+Ehr::Permissions::ice_write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    ::Ehr::ice_writeAccessType(__outS, defaultAccess);
+    ::Ehr::ice_writeAccessControlList(__outS, acl);
+}
+
+void
+Ehr::Permissions::ice_read(const ::Ice::InputStreamPtr& __inS)
+{
+    ::Ehr::ice_readAccessType(__inS, defaultAccess);
+    ::Ehr::ice_readAccessControlList(__inS, acl);
+}
+
+void
+Ehr::ice_writePermissions(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Permissions& __v)
+{
+    __v.ice_write(__outS);
+}
+
+void
+Ehr::ice_readPermissions(const ::Ice::InputStreamPtr& __inS, ::Ehr::Permissions& __v)
+{
+    __v.ice_read(__inS);
+}
+
+const ::std::string&
+IceProxy::Ehr::Document::ice_staticId()
+{
+    return ::Ehr::Document::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::Document::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Document);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::Document::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Document);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::Document::__newInstance() const
+{
+    return new Document;
+}
+
+const ::std::string&
+IceProxy::Ehr::Prescription::ice_staticId()
+{
+    return ::Ehr::Prescription::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::Prescription::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Prescription);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::Prescription::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Prescription);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::Prescription::__newInstance() const
+{
+    return new Prescription;
+}
+
+const ::std::string&
+IceProxy::Ehr::ConsumedPrescription::ice_staticId()
+{
+    return ::Ehr::ConsumedPrescription::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::ConsumedPrescription::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumedPrescription);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::ConsumedPrescription::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumedPrescription);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::ConsumedPrescription::__newInstance() const
+{
+    return new ConsumedPrescription;
+}
+
+const ::std::string&
+IceProxy::Ehr::Request::ice_staticId()
+{
+    return ::Ehr::Request::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::Request::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Request);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::Request::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Request);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::Request::__newInstance() const
+{
+    return new Request;
+}
+
+const ::std::string&
+IceProxy::Ehr::ThirdPartyRequest::ice_staticId()
+{
+    return ::Ehr::ThirdPartyRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::ThirdPartyRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ThirdPartyRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::ThirdPartyRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ThirdPartyRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::ThirdPartyRequest::__newInstance() const
+{
+    return new ThirdPartyRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::CreatePrescriptionRequest::ice_staticId()
+{
+    return ::Ehr::CreatePrescriptionRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePrescriptionRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePrescriptionRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::CreatePrescriptionRequest::__newInstance() const
+{
+    return new CreatePrescriptionRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::ConsumePrescriptionRequest::ice_staticId()
+{
+    return ::Ehr::ConsumePrescriptionRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumePrescriptionRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumePrescriptionRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::ConsumePrescriptionRequest::__newInstance() const
+{
+    return new ConsumePrescriptionRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::ListDocumentsRequest::ice_staticId()
+{
+    return ::Ehr::ListDocumentsRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::ListDocumentsRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListDocumentsRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::ListDocumentsRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListDocumentsRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::ListDocumentsRequest::__newInstance() const
+{
+    return new ListDocumentsRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::FindDocumentsRequest::ice_staticId()
+{
+    return ::Ehr::FindDocumentsRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::FindDocumentsRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::FindDocumentsRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::FindDocumentsRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::FindDocumentsRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::FindDocumentsRequest::__newInstance() const
+{
+    return new FindDocumentsRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::CreatePermissionRequest::ice_staticId()
+{
+    return ::Ehr::CreatePermissionRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::CreatePermissionRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePermissionRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::CreatePermissionRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePermissionRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::CreatePermissionRequest::__newInstance() const
+{
+    return new CreatePermissionRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::SetDefaultAccessRequest::ice_staticId()
+{
+    return ::Ehr::SetDefaultAccessRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::SetDefaultAccessRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::SetDefaultAccessRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::SetDefaultAccessRequest::__newInstance() const
+{
+    return new SetDefaultAccessRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::ListPermissionsRequest::ice_staticId()
+{
+    return ::Ehr::ListPermissionsRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::ListPermissionsRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListPermissionsRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::ListPermissionsRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListPermissionsRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::ListPermissionsRequest::__newInstance() const
+{
+    return new ListPermissionsRequest;
+}
+
+const ::std::string&
+IceProxy::Ehr::RemovePermissionRequest::ice_staticId()
+{
+    return ::Ehr::RemovePermissionRequest::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::RemovePermissionRequest::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::RemovePermissionRequest);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::RemovePermissionRequest::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::RemovePermissionRequest);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::RemovePermissionRequest::__newInstance() const
+{
+    return new RemovePermissionRequest;
+}
+
+void
+IceProxy::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__createPrescription_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            __del->createPrescription(request, requestorSignature, ownerSignature, __ctx);
+            return;
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+void
+IceProxy::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__consumePrescription_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            __del->consumePrescription(request, requestorSignature, ownerSignature, __ctx);
+            return;
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+::Ehr::DocumentList
+IceProxy::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__listDocuments_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            return __del->listDocuments(request, requestorSignature, ownerSignature, __ctx);
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+::Ehr::DocumentList
+IceProxy::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__findDocuments_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            return __del->findDocuments(request, requestorSignature, ownerSignature, __ctx);
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+void
+IceProxy::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__setDefaultAccess_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            __del->setDefaultAccess(request, requestorSignature, __ctx);
+            return;
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+void
+IceProxy::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__createPermission_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            __del->createPermission(request, requestorSignature, __ctx);
+            return;
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+::Ehr::Permissions
+IceProxy::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__listPermissions_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            return __del->listPermissions(request, requestorSignature, __ctx);
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+void
+IceProxy::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
+{
+    int __cnt = 0;
+    while(true)
+    {
+        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
+        try
+        {
+#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
+            IceUtil::DummyBCC dummy;
+#endif
+            __checkTwowayOnly(__Ehr__Provider__removePermission_name);
+            __delBase = __getDelegate(false);
+            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
+            __del->removePermission(request, requestorSignature, __ctx);
+            return;
+        }
+        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
+        {
+            __handleExceptionWrapper(__delBase, __ex, 0);
+        }
+        catch(const ::Ice::LocalException& __ex)
+        {
+            __handleException(__delBase, __ex, 0, __cnt);
+        }
+    }
+}
+
+const ::std::string&
+IceProxy::Ehr::Provider::ice_staticId()
+{
+    return ::Ehr::Provider::ice_staticId();
+}
+
+::IceInternal::Handle< ::IceDelegateM::Ice::Object>
+IceProxy::Ehr::Provider::__createDelegateM()
+{
+    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Provider);
+}
+
+::IceInternal::Handle< ::IceDelegateD::Ice::Object>
+IceProxy::Ehr::Provider::__createDelegateD()
+{
+    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Provider);
+}
+
+::IceProxy::Ice::Object*
+IceProxy::Ehr::Provider::__newInstance() const
+{
+    return new Provider;
+}
+
+void
+IceDelegateM::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        ownerSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        __og.is()->skipEmptyEncaps();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+void
+IceDelegateM::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        ownerSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        __og.is()->skipEmptyEncaps();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+::Ehr::DocumentList
+IceDelegateM::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        ownerSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    ::Ehr::DocumentList __ret;
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        ::IceInternal::BasicStream* __is = __og.is();
+        __is->startReadEncaps();
+        ::Ehr::__readDocumentList(__is, __ret);
+        __is->endReadEncaps();
+        return __ret;
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+::Ehr::DocumentList
+IceDelegateM::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        ownerSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    ::Ehr::DocumentList __ret;
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        ::IceInternal::BasicStream* __is = __og.is();
+        __is->startReadEncaps();
+        ::Ehr::__readDocumentList(__is, __ret);
+        __is->endReadEncaps();
+        return __ret;
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+void
+IceDelegateM::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        __og.is()->skipEmptyEncaps();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+void
+IceDelegateM::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        __og.is()->skipEmptyEncaps();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+::Ehr::Permissions
+IceDelegateM::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    ::Ehr::Permissions __ret;
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        ::IceInternal::BasicStream* __is = __og.is();
+        __is->startReadEncaps();
+        __ret.__read(__is);
+        __is->endReadEncaps();
+        return __ret;
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+void
+IceDelegateM::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
+    try
+    {
+        ::IceInternal::BasicStream* __os = __og.os();
+        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
+        requestorSignature.__write(__os);
+        __os->writePendingObjects();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        __og.abort(__ex);
+    }
+    bool __ok = __og.invoke();
+    try
+    {
+        if(!__ok)
+        {
+            try
+            {
+                __og.throwUserException();
+            }
+            catch(const ::Ehr::EhrException&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
+                throw __uue;
+            }
+        }
+        __og.is()->skipEmptyEncaps();
+    }
+    catch(const ::Ice::LocalException& __ex)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
+    }
+}
+
+void
+IceDelegateD::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature),
+            _m_ownerSignature(ownerSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                servant->createPrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        const ::Ehr::CreatePrescriptionRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+        const ::Ehr::Signature& _m_ownerSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
+    try
+    {
+        _DirectI __direct(request, requestorSignature, ownerSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+}
+
+void
+IceDelegateD::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature),
+            _m_ownerSignature(ownerSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                servant->consumePrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        const ::Ehr::ConsumePrescriptionRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+        const ::Ehr::Signature& _m_ownerSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
+    try
+    {
+        _DirectI __direct(request, requestorSignature, ownerSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+}
+
+::Ehr::DocumentList
+IceDelegateD::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(::Ehr::DocumentList& __result, const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _result(__result),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature),
+            _m_ownerSignature(ownerSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                _result = servant->listDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        ::Ehr::DocumentList& _result;
+        const ::Ehr::ListDocumentsRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+        const ::Ehr::Signature& _m_ownerSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
+    ::Ehr::DocumentList __result;
+    try
+    {
+        _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+    return __result;
+}
+
+::Ehr::DocumentList
+IceDelegateD::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(::Ehr::DocumentList& __result, const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _result(__result),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature),
+            _m_ownerSignature(ownerSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                _result = servant->findDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        ::Ehr::DocumentList& _result;
+        const ::Ehr::FindDocumentsRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+        const ::Ehr::Signature& _m_ownerSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
+    ::Ehr::DocumentList __result;
+    try
+    {
+        _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+    return __result;
+}
+
+void
+IceDelegateD::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                servant->setDefaultAccess(_m_request, _m_requestorSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        const ::Ehr::SetDefaultAccessRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
+    try
+    {
+        _DirectI __direct(request, requestorSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+}
+
+void
+IceDelegateD::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                servant->createPermission(_m_request, _m_requestorSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        const ::Ehr::CreatePermissionRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
+    try
+    {
+        _DirectI __direct(request, requestorSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+}
+
+::Ehr::Permissions
+IceDelegateD::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(::Ehr::Permissions& __result, const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _result(__result),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                _result = servant->listPermissions(_m_request, _m_requestorSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        ::Ehr::Permissions& _result;
+        const ::Ehr::ListPermissionsRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
+    ::Ehr::Permissions __result;
+    try
+    {
+        _DirectI __direct(__result, request, requestorSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+    return __result;
+}
+
+void
+IceDelegateD::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
+{
+    class _DirectI : public ::IceInternal::Direct
+    {
+    public:
+
+        _DirectI(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
+            ::IceInternal::Direct(__current),
+            _m_request(request),
+            _m_requestorSignature(requestorSignature)
+        {
+        }
+        
+        virtual ::Ice::DispatchStatus
+        run(::Ice::Object* object)
+        {
+            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
+            if(!servant)
+            {
+                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
+            }
+            try
+            {
+                servant->removePermission(_m_request, _m_requestorSignature, _current);
+                return ::Ice::DispatchOK;
+            }
+            catch(const ::Ice::UserException& __ex)
+            {
+                setUserException(__ex);
+                return ::Ice::DispatchUserException;
+            }
+        }
+        
+    private:
+        
+        const ::Ehr::RemovePermissionRequestPtr& _m_request;
+        const ::Ehr::Signature& _m_requestorSignature;
+    };
+    
+    ::Ice::Current __current;
+    __initCurrent(__current, __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
+    try
+    {
+        _DirectI __direct(request, requestorSignature, __current);
+        try
+        {
+            __direct.servant()->__collocDispatch(__direct);
+        }
+        catch(...)
+        {
+            __direct.destroy();
+            throw;
+        }
+        __direct.destroy();
+    }
+    catch(const ::Ehr::EhrException&)
+    {
+        throw;
+    }
+    catch(const ::Ice::SystemException&)
+    {
+        throw;
+    }
+    catch(const ::IceInternal::LocalExceptionWrapper&)
+    {
+        throw;
+    }
+    catch(const ::std::exception& __ex)
+    {
+        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
+    }
+    catch(...)
+    {
+        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
+    }
+}
+
+Ehr::Document::Document(::Ehr::DocumentType __ice_type) :
+    type(__ice_type)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::Document::ice_clone() const
+{
+    ::Ehr::DocumentPtr __p = new ::Ehr::Document(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__Document_ids[2] =
+{
+    "::Ehr::Document",
+    "::Ice::Object"
+};
+
+bool
+Ehr::Document::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__Document_ids, __Ehr__Document_ids + 2, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::Document::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__Document_ids[0], &__Ehr__Document_ids[2]);
+}
+
+const ::std::string&
+Ehr::Document::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__Document_ids[0];
+}
+
+const ::std::string&
+Ehr::Document::ice_staticId()
+{
+    return __Ehr__Document_ids[0];
+}
+
+void
+Ehr::Document::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    ::Ehr::__write(__os, type);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__os);
+#else
+    ::Ice::Object::__write(__os);
+#endif
+}
+
+void
+Ehr::Document::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    ::Ehr::__read(__is, type);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__is, true);
+#else
+    ::Ice::Object::__read(__is, true);
+#endif
+}
+
+void
+Ehr::Document::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    ::Ehr::ice_writeDocumentType(__outS, type);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__outS);
+#else
+    ::Ice::Object::__write(__outS);
+#endif
+}
+
+void
+Ehr::Document::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    ::Ehr::ice_readDocumentType(__inS, type);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__inS, true);
+#else
+    ::Ice::Object::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__Document : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::Document::ice_staticId());
+        return new ::Ehr::Document;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__Document_Ptr = new __F__Ehr__Document;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::Document::ice_factory()
+{
+    return __F__Ehr__Document_Ptr;
+}
+
+class __F__Ehr__Document__Init
+{
+public:
+
+    __F__Ehr__Document__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Document::ice_staticId(), ::Ehr::Document::ice_factory());
+    }
+
+    ~__F__Ehr__Document__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Document::ice_staticId());
+    }
+};
+
+static __F__Ehr__Document__Init __F__Ehr__Document__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__Document__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__DocumentPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::DocumentPtr* p = static_cast< ::Ehr::DocumentPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::DocumentPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::Document::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::Document& l, const ::Ehr::Document& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::Document& l, const ::Ehr::Document& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::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) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document(__ice_type)
+#else
+    ::Ehr::Document(__ice_type)
+#endif
+,
+    originatorName(__ice_originatorName),
+    originatorProfession(__ice_originatorProfession),
+    originatorAddress(__ice_originatorAddress),
+    creationDate(__ice_creationDate),
+    consumerName(__ice_consumerName),
+    consumerDateOfBirth(__ice_consumerDateOfBirth),
+    drugDescription(__ice_drugDescription),
+    form(__ice_form),
+    dosage(__ice_dosage),
+    measuringUnit(__ice_measuringUnit),
+    validFrom(__ice_validFrom),
+    expires(__ice_expires)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::Prescription::ice_clone() const
+{
+    ::Ehr::PrescriptionPtr __p = new ::Ehr::Prescription(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__Prescription_ids[3] =
+{
+    "::Ehr::Document",
+    "::Ehr::Prescription",
+    "::Ice::Object"
+};
+
+bool
+Ehr::Prescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__Prescription_ids, __Ehr__Prescription_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::Prescription::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__Prescription_ids[0], &__Ehr__Prescription_ids[3]);
+}
+
+const ::std::string&
+Ehr::Prescription::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__Prescription_ids[1];
+}
+
+const ::std::string&
+Ehr::Prescription::ice_staticId()
+{
+    return __Ehr__Prescription_ids[1];
+}
+
+void
+Ehr::Prescription::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(originatorName);
+    __os->write(originatorProfession);
+    __os->write(originatorAddress);
+    creationDate.__write(__os);
+    __os->write(consumerName);
+    consumerDateOfBirth.__write(__os);
+    __os->write(drugDescription);
+    __os->write(form);
+    __os->write(dosage);
+    __os->write(measuringUnit);
+    validFrom.__write(__os);
+    expires.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document::__write(__os);
+#else
+    ::Ehr::Document::__write(__os);
+#endif
+}
+
+void
+Ehr::Prescription::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(originatorName);
+    __is->read(originatorProfession);
+    __is->read(originatorAddress);
+    creationDate.__read(__is);
+    __is->read(consumerName);
+    consumerDateOfBirth.__read(__is);
+    __is->read(drugDescription);
+    __is->read(form);
+    __is->read(dosage);
+    __is->read(measuringUnit);
+    validFrom.__read(__is);
+    expires.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document::__read(__is, true);
+#else
+    ::Ehr::Document::__read(__is, true);
+#endif
+}
+
+void
+Ehr::Prescription::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeString(originatorName);
+    __outS->writeString(originatorProfession);
+    __outS->writeString(originatorAddress);
+    ::Ehr::ice_writeDate(__outS, creationDate);
+    __outS->writeString(consumerName);
+    ::Ehr::ice_writeDate(__outS, consumerDateOfBirth);
+    __outS->writeString(drugDescription);
+    __outS->writeString(form);
+    __outS->writeInt(dosage);
+    __outS->writeString(measuringUnit);
+    ::Ehr::ice_writeDate(__outS, validFrom);
+    ::Ehr::ice_writeDate(__outS, expires);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document::__write(__outS);
+#else
+    ::Ehr::Document::__write(__outS);
+#endif
+}
+
+void
+Ehr::Prescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    originatorName = __inS->readString();
+    originatorProfession = __inS->readString();
+    originatorAddress = __inS->readString();
+    ::Ehr::ice_readDate(__inS, creationDate);
+    consumerName = __inS->readString();
+    ::Ehr::ice_readDate(__inS, consumerDateOfBirth);
+    drugDescription = __inS->readString();
+    form = __inS->readString();
+    dosage = __inS->readInt();
+    measuringUnit = __inS->readString();
+    ::Ehr::ice_readDate(__inS, validFrom);
+    ::Ehr::ice_readDate(__inS, expires);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document::__read(__inS, true);
+#else
+    ::Ehr::Document::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__Prescription : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::Prescription::ice_staticId());
+        return new ::Ehr::Prescription;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__Prescription_Ptr = new __F__Ehr__Prescription;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::Prescription::ice_factory()
+{
+    return __F__Ehr__Prescription_Ptr;
+}
+
+class __F__Ehr__Prescription__Init
+{
+public:
+
+    __F__Ehr__Prescription__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Prescription::ice_staticId(), ::Ehr::Prescription::ice_factory());
+    }
+
+    ~__F__Ehr__Prescription__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Prescription::ice_staticId());
+    }
+};
+
+static __F__Ehr__Prescription__Init __F__Ehr__Prescription__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__Prescription__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__PrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::PrescriptionPtr* p = static_cast< ::Ehr::PrescriptionPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::PrescriptionPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::Prescription::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::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) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Document(__ice_type)
+#else
+    ::Ehr::Document(__ice_type)
+#endif
+,
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    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)
+#else
+    ::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)
+#endif
+,
+    dispenserName(__ice_dispenserName),
+    dispenserProfession(__ice_dispenserProfession),
+    dispenserAddress(__ice_dispenserAddress),
+    dispensingDate(__ice_dispensingDate)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::ConsumedPrescription::ice_clone() const
+{
+    ::Ehr::ConsumedPrescriptionPtr __p = new ::Ehr::ConsumedPrescription(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__ConsumedPrescription_ids[4] =
+{
+    "::Ehr::ConsumedPrescription",
+    "::Ehr::Document",
+    "::Ehr::Prescription",
+    "::Ice::Object"
+};
+
+bool
+Ehr::ConsumedPrescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__ConsumedPrescription_ids, __Ehr__ConsumedPrescription_ids + 4, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::ConsumedPrescription::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__ConsumedPrescription_ids[0], &__Ehr__ConsumedPrescription_ids[4]);
+}
+
+const ::std::string&
+Ehr::ConsumedPrescription::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__ConsumedPrescription_ids[0];
+}
+
+const ::std::string&
+Ehr::ConsumedPrescription::ice_staticId()
+{
+    return __Ehr__ConsumedPrescription_ids[0];
+}
+
+void
+Ehr::ConsumedPrescription::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(dispenserName);
+    __os->write(dispenserProfession);
+    __os->write(dispenserAddress);
+    dispensingDate.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Prescription::__write(__os);
+#else
+    ::Ehr::Prescription::__write(__os);
+#endif
+}
+
+void
+Ehr::ConsumedPrescription::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(dispenserName);
+    __is->read(dispenserProfession);
+    __is->read(dispenserAddress);
+    dispensingDate.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Prescription::__read(__is, true);
+#else
+    ::Ehr::Prescription::__read(__is, true);
+#endif
+}
+
+void
+Ehr::ConsumedPrescription::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeString(dispenserName);
+    __outS->writeString(dispenserProfession);
+    __outS->writeString(dispenserAddress);
+    ::Ehr::ice_writeDate(__outS, dispensingDate);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Prescription::__write(__outS);
+#else
+    ::Ehr::Prescription::__write(__outS);
+#endif
+}
+
+void
+Ehr::ConsumedPrescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    dispenserName = __inS->readString();
+    dispenserProfession = __inS->readString();
+    dispenserAddress = __inS->readString();
+    ::Ehr::ice_readDate(__inS, dispensingDate);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Prescription::__read(__inS, true);
+#else
+    ::Ehr::Prescription::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__ConsumedPrescription : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::ConsumedPrescription::ice_staticId());
+        return new ::Ehr::ConsumedPrescription;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumedPrescription_Ptr = new __F__Ehr__ConsumedPrescription;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::ConsumedPrescription::ice_factory()
+{
+    return __F__Ehr__ConsumedPrescription_Ptr;
+}
+
+class __F__Ehr__ConsumedPrescription__Init
+{
+public:
+
+    __F__Ehr__ConsumedPrescription__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumedPrescription::ice_staticId(), ::Ehr::ConsumedPrescription::ice_factory());
+    }
+
+    ~__F__Ehr__ConsumedPrescription__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumedPrescription::ice_staticId());
+    }
+};
+
+static __F__Ehr__ConsumedPrescription__Init __F__Ehr__ConsumedPrescription__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__ConsumedPrescription__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__ConsumedPrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ConsumedPrescriptionPtr* p = static_cast< ::Ehr::ConsumedPrescriptionPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ConsumedPrescriptionPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::ConsumedPrescription::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::Request::Request(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when) :
+    requestor(__ice_requestor),
+    when(__ice_when)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::Request::ice_clone() const
+{
+    ::Ehr::RequestPtr __p = new ::Ehr::Request(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__Request_ids[2] =
+{
+    "::Ehr::Request",
+    "::Ice::Object"
+};
+
+bool
+Ehr::Request::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__Request_ids, __Ehr__Request_ids + 2, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::Request::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__Request_ids[0], &__Ehr__Request_ids[2]);
+}
+
+const ::std::string&
+Ehr::Request::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__Request_ids[0];
+}
+
+const ::std::string&
+Ehr::Request::ice_staticId()
+{
+    return __Ehr__Request_ids[0];
+}
+
+void
+Ehr::Request::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    requestor.__write(__os);
+    when.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__os);
+#else
+    ::Ice::Object::__write(__os);
+#endif
+}
+
+void
+Ehr::Request::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    requestor.__read(__is);
+    when.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__is, true);
+#else
+    ::Ice::Object::__read(__is, true);
+#endif
+}
+
+void
+Ehr::Request::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    ::Ehr::ice_writeAccountIdentifier(__outS, requestor);
+    ::Ehr::ice_writeTimestamp(__outS, when);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__outS);
+#else
+    ::Ice::Object::__write(__outS);
+#endif
+}
+
+void
+Ehr::Request::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    ::Ehr::ice_readAccountIdentifier(__inS, requestor);
+    ::Ehr::ice_readTimestamp(__inS, when);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__inS, true);
+#else
+    ::Ice::Object::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__Request : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::Request::ice_staticId());
+        return new ::Ehr::Request;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__Request_Ptr = new __F__Ehr__Request;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::Request::ice_factory()
+{
+    return __F__Ehr__Request_Ptr;
+}
+
+class __F__Ehr__Request__Init
+{
+public:
+
+    __F__Ehr__Request__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Request::ice_staticId(), ::Ehr::Request::ice_factory());
+    }
+
+    ~__F__Ehr__Request__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Request::ice_staticId());
+    }
+};
+
+static __F__Ehr__Request__Init __F__Ehr__Request__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__Request__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__RequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::RequestPtr* p = static_cast< ::Ehr::RequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::RequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::Request::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::Request& l, const ::Ehr::Request& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::Request& l, const ::Ehr::Request& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::ThirdPartyRequest::ThirdPartyRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+    owner(__ice_owner)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::ThirdPartyRequest::ice_clone() const
+{
+    ::Ehr::ThirdPartyRequestPtr __p = new ::Ehr::ThirdPartyRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__ThirdPartyRequest_ids[3] =
+{
+    "::Ehr::Request",
+    "::Ehr::ThirdPartyRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::ThirdPartyRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__ThirdPartyRequest_ids, __Ehr__ThirdPartyRequest_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::ThirdPartyRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__ThirdPartyRequest_ids[0], &__Ehr__ThirdPartyRequest_ids[3]);
+}
+
+const ::std::string&
+Ehr::ThirdPartyRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__ThirdPartyRequest_ids[1];
+}
+
+const ::std::string&
+Ehr::ThirdPartyRequest::ice_staticId()
+{
+    return __Ehr__ThirdPartyRequest_ids[1];
+}
+
+void
+Ehr::ThirdPartyRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    owner.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__os);
+#else
+    ::Ehr::Request::__write(__os);
+#endif
+}
+
+void
+Ehr::ThirdPartyRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    owner.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__is, true);
+#else
+    ::Ehr::Request::__read(__is, true);
+#endif
+}
+
+void
+Ehr::ThirdPartyRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    ::Ehr::ice_writeAccountIdentifier(__outS, owner);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__outS);
+#else
+    ::Ehr::Request::__write(__outS);
+#endif
+}
+
+void
+Ehr::ThirdPartyRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    ::Ehr::ice_readAccountIdentifier(__inS, owner);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__inS, true);
+#else
+    ::Ehr::Request::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__ThirdPartyRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::ThirdPartyRequest::ice_staticId());
+        return new ::Ehr::ThirdPartyRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__ThirdPartyRequest_Ptr = new __F__Ehr__ThirdPartyRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::ThirdPartyRequest::ice_factory()
+{
+    return __F__Ehr__ThirdPartyRequest_Ptr;
+}
+
+class __F__Ehr__ThirdPartyRequest__Init
+{
+public:
+
+    __F__Ehr__ThirdPartyRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId(), ::Ehr::ThirdPartyRequest::ice_factory());
+    }
+
+    ~__F__Ehr__ThirdPartyRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__ThirdPartyRequest__Init __F__Ehr__ThirdPartyRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__ThirdPartyRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__ThirdPartyRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ThirdPartyRequestPtr* p = static_cast< ::Ehr::ThirdPartyRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ThirdPartyRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::ThirdPartyRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::CreatePrescriptionRequest::CreatePrescriptionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, const ::Ehr::EncryptedDocument& __ice_prescription) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#else
+    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#endif
+,
+    prescription(__ice_prescription)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::CreatePrescriptionRequest::ice_clone() const
+{
+    ::Ehr::CreatePrescriptionRequestPtr __p = new ::Ehr::CreatePrescriptionRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__CreatePrescriptionRequest_ids[4] =
+{
+    "::Ehr::CreatePrescriptionRequest",
+    "::Ehr::Request",
+    "::Ehr::ThirdPartyRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::CreatePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__CreatePrescriptionRequest_ids, __Ehr__CreatePrescriptionRequest_ids + 4, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::CreatePrescriptionRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__CreatePrescriptionRequest_ids[0], &__Ehr__CreatePrescriptionRequest_ids[4]);
+}
+
+const ::std::string&
+Ehr::CreatePrescriptionRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__CreatePrescriptionRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::CreatePrescriptionRequest::ice_staticId()
+{
+    return __Ehr__CreatePrescriptionRequest_ids[0];
+}
+
+void
+Ehr::CreatePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    prescription.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__os);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__os);
+#endif
+}
+
+void
+Ehr::CreatePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    prescription.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__is, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__is, true);
+#endif
+}
+
+void
+Ehr::CreatePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    ::Ehr::ice_writeEncryptedDocument(__outS, prescription);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__outS);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__outS);
+#endif
+}
+
+void
+Ehr::CreatePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    ::Ehr::ice_readEncryptedDocument(__inS, prescription);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__inS, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__CreatePrescriptionRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::CreatePrescriptionRequest::ice_staticId());
+        return new ::Ehr::CreatePrescriptionRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePrescriptionRequest_Ptr = new __F__Ehr__CreatePrescriptionRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::CreatePrescriptionRequest::ice_factory()
+{
+    return __F__Ehr__CreatePrescriptionRequest_Ptr;
+}
+
+class __F__Ehr__CreatePrescriptionRequest__Init
+{
+public:
+
+    __F__Ehr__CreatePrescriptionRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId(), ::Ehr::CreatePrescriptionRequest::ice_factory());
+    }
+
+    ~__F__Ehr__CreatePrescriptionRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__CreatePrescriptionRequest__Init __F__Ehr__CreatePrescriptionRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__CreatePrescriptionRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__CreatePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::CreatePrescriptionRequestPtr* p = static_cast< ::Ehr::CreatePrescriptionRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::CreatePrescriptionRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::CreatePrescriptionRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::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) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#else
+    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#endif
+,
+    prescriptionId(__ice_prescriptionId),
+    consumedPrescription(__ice_consumedPrescription)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::ConsumePrescriptionRequest::ice_clone() const
+{
+    ::Ehr::ConsumePrescriptionRequestPtr __p = new ::Ehr::ConsumePrescriptionRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__ConsumePrescriptionRequest_ids[4] =
+{
+    "::Ehr::ConsumePrescriptionRequest",
+    "::Ehr::Request",
+    "::Ehr::ThirdPartyRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::ConsumePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__ConsumePrescriptionRequest_ids, __Ehr__ConsumePrescriptionRequest_ids + 4, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::ConsumePrescriptionRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__ConsumePrescriptionRequest_ids[0], &__Ehr__ConsumePrescriptionRequest_ids[4]);
+}
+
+const ::std::string&
+Ehr::ConsumePrescriptionRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__ConsumePrescriptionRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::ConsumePrescriptionRequest::ice_staticId()
+{
+    return __Ehr__ConsumePrescriptionRequest_ids[0];
+}
+
+void
+Ehr::ConsumePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(prescriptionId);
+    consumedPrescription.__write(__os);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__os);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__os);
+#endif
+}
+
+void
+Ehr::ConsumePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(prescriptionId);
+    consumedPrescription.__read(__is);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__is, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__is, true);
+#endif
+}
+
+void
+Ehr::ConsumePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeLong(prescriptionId);
+    ::Ehr::ice_writeEncryptedDocument(__outS, consumedPrescription);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__outS);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__outS);
+#endif
+}
+
+void
+Ehr::ConsumePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    prescriptionId = __inS->readLong();
+    ::Ehr::ice_readEncryptedDocument(__inS, consumedPrescription);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__inS, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__ConsumePrescriptionRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::ConsumePrescriptionRequest::ice_staticId());
+        return new ::Ehr::ConsumePrescriptionRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumePrescriptionRequest_Ptr = new __F__Ehr__ConsumePrescriptionRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::ConsumePrescriptionRequest::ice_factory()
+{
+    return __F__Ehr__ConsumePrescriptionRequest_Ptr;
+}
+
+class __F__Ehr__ConsumePrescriptionRequest__Init
+{
+public:
+
+    __F__Ehr__ConsumePrescriptionRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId(), ::Ehr::ConsumePrescriptionRequest::ice_factory());
+    }
+
+    ~__F__Ehr__ConsumePrescriptionRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__ConsumePrescriptionRequest__Init __F__Ehr__ConsumePrescriptionRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__ConsumePrescriptionRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__ConsumePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ConsumePrescriptionRequestPtr* p = static_cast< ::Ehr::ConsumePrescriptionRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ConsumePrescriptionRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::ConsumePrescriptionRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::ListDocumentsRequest::ListDocumentsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#else
+    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#endif
+
+{
+}
+
+::Ice::ObjectPtr
+Ehr::ListDocumentsRequest::ice_clone() const
+{
+    ::Ehr::ListDocumentsRequestPtr __p = new ::Ehr::ListDocumentsRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__ListDocumentsRequest_ids[4] =
+{
+    "::Ehr::ListDocumentsRequest",
+    "::Ehr::Request",
+    "::Ehr::ThirdPartyRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::ListDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__ListDocumentsRequest_ids, __Ehr__ListDocumentsRequest_ids + 4, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::ListDocumentsRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__ListDocumentsRequest_ids[0], &__Ehr__ListDocumentsRequest_ids[4]);
+}
+
+const ::std::string&
+Ehr::ListDocumentsRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__ListDocumentsRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::ListDocumentsRequest::ice_staticId()
+{
+    return __Ehr__ListDocumentsRequest_ids[0];
+}
+
+void
+Ehr::ListDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__os);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__os);
+#endif
+}
+
+void
+Ehr::ListDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__is, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__is, true);
+#endif
+}
+
+void
+Ehr::ListDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__outS);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__outS);
+#endif
+}
+
+void
+Ehr::ListDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__inS, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__ListDocumentsRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::ListDocumentsRequest::ice_staticId());
+        return new ::Ehr::ListDocumentsRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__ListDocumentsRequest_Ptr = new __F__Ehr__ListDocumentsRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::ListDocumentsRequest::ice_factory()
+{
+    return __F__Ehr__ListDocumentsRequest_Ptr;
+}
+
+class __F__Ehr__ListDocumentsRequest__Init
+{
+public:
+
+    __F__Ehr__ListDocumentsRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId(), ::Ehr::ListDocumentsRequest::ice_factory());
+    }
+
+    ~__F__Ehr__ListDocumentsRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__ListDocumentsRequest__Init __F__Ehr__ListDocumentsRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__ListDocumentsRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__ListDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ListDocumentsRequestPtr* p = static_cast< ::Ehr::ListDocumentsRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ListDocumentsRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::ListDocumentsRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::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) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#else
+    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
+#endif
+,
+    hasFrom(__ice_hasFrom),
+    from(__ice_from),
+    hasTill(__ice_hasTill),
+    till(__ice_till),
+    type(__ice_type),
+    documentId(__ice_documentId)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::FindDocumentsRequest::ice_clone() const
+{
+    ::Ehr::FindDocumentsRequestPtr __p = new ::Ehr::FindDocumentsRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__FindDocumentsRequest_ids[4] =
+{
+    "::Ehr::FindDocumentsRequest",
+    "::Ehr::Request",
+    "::Ehr::ThirdPartyRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::FindDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__FindDocumentsRequest_ids, __Ehr__FindDocumentsRequest_ids + 4, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::FindDocumentsRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__FindDocumentsRequest_ids[0], &__Ehr__FindDocumentsRequest_ids[4]);
+}
+
+const ::std::string&
+Ehr::FindDocumentsRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__FindDocumentsRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::FindDocumentsRequest::ice_staticId()
+{
+    return __Ehr__FindDocumentsRequest_ids[0];
+}
+
+void
+Ehr::FindDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(hasFrom);
+    from.__write(__os);
+    __os->write(hasTill);
+    till.__write(__os);
+    ::Ehr::__write(__os, type);
+    __os->write(documentId);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__os);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__os);
+#endif
+}
+
+void
+Ehr::FindDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(hasFrom);
+    from.__read(__is);
+    __is->read(hasTill);
+    till.__read(__is);
+    ::Ehr::__read(__is, type);
+    __is->read(documentId);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__is, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__is, true);
+#endif
+}
+
+void
+Ehr::FindDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeBool(hasFrom);
+    ::Ehr::ice_writeTimestamp(__outS, from);
+    __outS->writeBool(hasTill);
+    ::Ehr::ice_writeTimestamp(__outS, till);
+    ::Ehr::ice_writeDocumentType(__outS, type);
+    __outS->writeLong(documentId);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__write(__outS);
+#else
+    ::Ehr::ThirdPartyRequest::__write(__outS);
+#endif
+}
+
+void
+Ehr::FindDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    hasFrom = __inS->readBool();
+    ::Ehr::ice_readTimestamp(__inS, from);
+    hasTill = __inS->readBool();
+    ::Ehr::ice_readTimestamp(__inS, till);
+    ::Ehr::ice_readDocumentType(__inS, type);
+    documentId = __inS->readLong();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    ThirdPartyRequest::__read(__inS, true);
+#else
+    ::Ehr::ThirdPartyRequest::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__FindDocumentsRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::FindDocumentsRequest::ice_staticId());
+        return new ::Ehr::FindDocumentsRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__FindDocumentsRequest_Ptr = new __F__Ehr__FindDocumentsRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::FindDocumentsRequest::ice_factory()
+{
+    return __F__Ehr__FindDocumentsRequest_Ptr;
+}
+
+class __F__Ehr__FindDocumentsRequest__Init
+{
+public:
+
+    __F__Ehr__FindDocumentsRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId(), ::Ehr::FindDocumentsRequest::ice_factory());
+    }
+
+    ~__F__Ehr__FindDocumentsRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__FindDocumentsRequest__Init __F__Ehr__FindDocumentsRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__FindDocumentsRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__FindDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::FindDocumentsRequestPtr* p = static_cast< ::Ehr::FindDocumentsRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::FindDocumentsRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::FindDocumentsRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::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) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+    documentId(__ice_documentId),
+    account(__ice_account),
+    access(__ice_access)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::CreatePermissionRequest::ice_clone() const
+{
+    ::Ehr::CreatePermissionRequestPtr __p = new ::Ehr::CreatePermissionRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__CreatePermissionRequest_ids[3] =
+{
+    "::Ehr::CreatePermissionRequest",
+    "::Ehr::Request",
+    "::Ice::Object"
+};
+
+bool
+Ehr::CreatePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__CreatePermissionRequest_ids, __Ehr__CreatePermissionRequest_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::CreatePermissionRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__CreatePermissionRequest_ids[0], &__Ehr__CreatePermissionRequest_ids[3]);
+}
+
+const ::std::string&
+Ehr::CreatePermissionRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__CreatePermissionRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::CreatePermissionRequest::ice_staticId()
+{
+    return __Ehr__CreatePermissionRequest_ids[0];
+}
+
+void
+Ehr::CreatePermissionRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(documentId);
+    account.__write(__os);
+    ::Ehr::__write(__os, access);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__os);
+#else
+    ::Ehr::Request::__write(__os);
+#endif
+}
+
+void
+Ehr::CreatePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(documentId);
+    account.__read(__is);
+    ::Ehr::__read(__is, access);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__is, true);
+#else
+    ::Ehr::Request::__read(__is, true);
+#endif
+}
+
+void
+Ehr::CreatePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeLong(documentId);
+    ::Ehr::ice_writeAccountIdentifier(__outS, account);
+    ::Ehr::ice_writeAccessType(__outS, access);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__outS);
+#else
+    ::Ehr::Request::__write(__outS);
+#endif
+}
+
+void
+Ehr::CreatePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    documentId = __inS->readLong();
+    ::Ehr::ice_readAccountIdentifier(__inS, account);
+    ::Ehr::ice_readAccessType(__inS, access);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__inS, true);
+#else
+    ::Ehr::Request::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__CreatePermissionRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::CreatePermissionRequest::ice_staticId());
+        return new ::Ehr::CreatePermissionRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePermissionRequest_Ptr = new __F__Ehr__CreatePermissionRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::CreatePermissionRequest::ice_factory()
+{
+    return __F__Ehr__CreatePermissionRequest_Ptr;
+}
+
+class __F__Ehr__CreatePermissionRequest__Init
+{
+public:
+
+    __F__Ehr__CreatePermissionRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId(), ::Ehr::CreatePermissionRequest::ice_factory());
+    }
+
+    ~__F__Ehr__CreatePermissionRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__CreatePermissionRequest__Init __F__Ehr__CreatePermissionRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__CreatePermissionRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__CreatePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::CreatePermissionRequestPtr* p = static_cast< ::Ehr::CreatePermissionRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::CreatePermissionRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::CreatePermissionRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::SetDefaultAccessRequest::SetDefaultAccessRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ehr::AccessType __ice_access) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+    documentId(__ice_documentId),
+    access(__ice_access)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::SetDefaultAccessRequest::ice_clone() const
+{
+    ::Ehr::SetDefaultAccessRequestPtr __p = new ::Ehr::SetDefaultAccessRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__SetDefaultAccessRequest_ids[3] =
+{
+    "::Ehr::Request",
+    "::Ehr::SetDefaultAccessRequest",
+    "::Ice::Object"
+};
+
+bool
+Ehr::SetDefaultAccessRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__SetDefaultAccessRequest_ids, __Ehr__SetDefaultAccessRequest_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::SetDefaultAccessRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__SetDefaultAccessRequest_ids[0], &__Ehr__SetDefaultAccessRequest_ids[3]);
+}
+
+const ::std::string&
+Ehr::SetDefaultAccessRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__SetDefaultAccessRequest_ids[1];
+}
+
+const ::std::string&
+Ehr::SetDefaultAccessRequest::ice_staticId()
+{
+    return __Ehr__SetDefaultAccessRequest_ids[1];
+}
+
+void
+Ehr::SetDefaultAccessRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(documentId);
+    ::Ehr::__write(__os, access);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__os);
+#else
+    ::Ehr::Request::__write(__os);
+#endif
+}
+
+void
+Ehr::SetDefaultAccessRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(documentId);
+    ::Ehr::__read(__is, access);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__is, true);
+#else
+    ::Ehr::Request::__read(__is, true);
+#endif
+}
+
+void
+Ehr::SetDefaultAccessRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeLong(documentId);
+    ::Ehr::ice_writeAccessType(__outS, access);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__outS);
+#else
+    ::Ehr::Request::__write(__outS);
+#endif
+}
+
+void
+Ehr::SetDefaultAccessRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    documentId = __inS->readLong();
+    ::Ehr::ice_readAccessType(__inS, access);
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__inS, true);
+#else
+    ::Ehr::Request::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__SetDefaultAccessRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::SetDefaultAccessRequest::ice_staticId());
+        return new ::Ehr::SetDefaultAccessRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__SetDefaultAccessRequest_Ptr = new __F__Ehr__SetDefaultAccessRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::SetDefaultAccessRequest::ice_factory()
+{
+    return __F__Ehr__SetDefaultAccessRequest_Ptr;
+}
+
+class __F__Ehr__SetDefaultAccessRequest__Init
+{
+public:
+
+    __F__Ehr__SetDefaultAccessRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId(), ::Ehr::SetDefaultAccessRequest::ice_factory());
+    }
+
+    ~__F__Ehr__SetDefaultAccessRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__SetDefaultAccessRequest__Init __F__Ehr__SetDefaultAccessRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__SetDefaultAccessRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__SetDefaultAccessRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::SetDefaultAccessRequestPtr* p = static_cast< ::Ehr::SetDefaultAccessRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::SetDefaultAccessRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::SetDefaultAccessRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::ListPermissionsRequest::ListPermissionsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+    documentId(__ice_documentId)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::ListPermissionsRequest::ice_clone() const
+{
+    ::Ehr::ListPermissionsRequestPtr __p = new ::Ehr::ListPermissionsRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__ListPermissionsRequest_ids[3] =
+{
+    "::Ehr::ListPermissionsRequest",
+    "::Ehr::Request",
+    "::Ice::Object"
+};
+
+bool
+Ehr::ListPermissionsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__ListPermissionsRequest_ids, __Ehr__ListPermissionsRequest_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::ListPermissionsRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__ListPermissionsRequest_ids[0], &__Ehr__ListPermissionsRequest_ids[3]);
+}
+
+const ::std::string&
+Ehr::ListPermissionsRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__ListPermissionsRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::ListPermissionsRequest::ice_staticId()
+{
+    return __Ehr__ListPermissionsRequest_ids[0];
+}
+
+void
+Ehr::ListPermissionsRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(documentId);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__os);
+#else
+    ::Ehr::Request::__write(__os);
+#endif
+}
+
+void
+Ehr::ListPermissionsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(documentId);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__is, true);
+#else
+    ::Ehr::Request::__read(__is, true);
+#endif
+}
+
+void
+Ehr::ListPermissionsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeLong(documentId);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__outS);
+#else
+    ::Ehr::Request::__write(__outS);
+#endif
+}
+
+void
+Ehr::ListPermissionsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    documentId = __inS->readLong();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__inS, true);
+#else
+    ::Ehr::Request::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__ListPermissionsRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::ListPermissionsRequest::ice_staticId());
+        return new ::Ehr::ListPermissionsRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__ListPermissionsRequest_Ptr = new __F__Ehr__ListPermissionsRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::ListPermissionsRequest::ice_factory()
+{
+    return __F__Ehr__ListPermissionsRequest_Ptr;
+}
+
+class __F__Ehr__ListPermissionsRequest__Init
+{
+public:
+
+    __F__Ehr__ListPermissionsRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId(), ::Ehr::ListPermissionsRequest::ice_factory());
+    }
+
+    ~__F__Ehr__ListPermissionsRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__ListPermissionsRequest__Init __F__Ehr__ListPermissionsRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__ListPermissionsRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__ListPermissionsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ListPermissionsRequestPtr* p = static_cast< ::Ehr::ListPermissionsRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ListPermissionsRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::ListPermissionsRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+Ehr::RemovePermissionRequest::RemovePermissionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ice::Long __ice_permissionId) :
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request(__ice_requestor, __ice_when)
+#else
+    ::Ehr::Request(__ice_requestor, __ice_when)
+#endif
+,
+    documentId(__ice_documentId),
+    permissionId(__ice_permissionId)
+{
+}
+
+::Ice::ObjectPtr
+Ehr::RemovePermissionRequest::ice_clone() const
+{
+    ::Ehr::RemovePermissionRequestPtr __p = new ::Ehr::RemovePermissionRequest(*this);
+    return __p;
+}
+
+static const ::std::string __Ehr__RemovePermissionRequest_ids[3] =
+{
+    "::Ehr::RemovePermissionRequest",
+    "::Ehr::Request",
+    "::Ice::Object"
+};
+
+bool
+Ehr::RemovePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__RemovePermissionRequest_ids, __Ehr__RemovePermissionRequest_ids + 3, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::RemovePermissionRequest::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__RemovePermissionRequest_ids[0], &__Ehr__RemovePermissionRequest_ids[3]);
+}
+
+const ::std::string&
+Ehr::RemovePermissionRequest::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__RemovePermissionRequest_ids[0];
+}
+
+const ::std::string&
+Ehr::RemovePermissionRequest::ice_staticId()
+{
+    return __Ehr__RemovePermissionRequest_ids[0];
+}
+
+void
+Ehr::RemovePermissionRequest::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->write(documentId);
+    __os->write(permissionId);
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__os);
+#else
+    ::Ehr::Request::__write(__os);
+#endif
+}
+
+void
+Ehr::RemovePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->read(documentId);
+    __is->read(permissionId);
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__is, true);
+#else
+    ::Ehr::Request::__read(__is, true);
+#endif
+}
+
+void
+Ehr::RemovePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeLong(documentId);
+    __outS->writeLong(permissionId);
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__write(__outS);
+#else
+    ::Ehr::Request::__write(__outS);
+#endif
+}
+
+void
+Ehr::RemovePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    documentId = __inS->readLong();
+    permissionId = __inS->readLong();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Request::__read(__inS, true);
+#else
+    ::Ehr::Request::__read(__inS, true);
+#endif
+}
+
+class __F__Ehr__RemovePermissionRequest : public ::Ice::ObjectFactory
+{
+public:
+
+    virtual ::Ice::ObjectPtr
+    create(const ::std::string& type)
+    {
+        assert(type == ::Ehr::RemovePermissionRequest::ice_staticId());
+        return new ::Ehr::RemovePermissionRequest;
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+};
+
+static ::Ice::ObjectFactoryPtr __F__Ehr__RemovePermissionRequest_Ptr = new __F__Ehr__RemovePermissionRequest;
+
+const ::Ice::ObjectFactoryPtr&
+Ehr::RemovePermissionRequest::ice_factory()
+{
+    return __F__Ehr__RemovePermissionRequest_Ptr;
+}
+
+class __F__Ehr__RemovePermissionRequest__Init
+{
+public:
+
+    __F__Ehr__RemovePermissionRequest__Init()
+    {
+        ::IceInternal::factoryTable->addObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId(), ::Ehr::RemovePermissionRequest::ice_factory());
+    }
+
+    ~__F__Ehr__RemovePermissionRequest__Init()
+    {
+        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId());
+    }
+};
+
+static __F__Ehr__RemovePermissionRequest__Init __F__Ehr__RemovePermissionRequest__i;
+
+#ifdef __APPLE__
+extern "C" { void __F__Ehr__RemovePermissionRequest__initializer() {} }
+#endif
+
+void 
+Ehr::__patch__RemovePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::RemovePermissionRequestPtr* p = static_cast< ::Ehr::RemovePermissionRequestPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::RemovePermissionRequestPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::RemovePermissionRequest::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}
+
+::Ice::ObjectPtr
+Ehr::Provider::ice_clone() const
+{
+    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
+    return 0; // to avoid a warning with some compilers
+}
+
+static const ::std::string __Ehr__Provider_ids[2] =
+{
+    "::Ehr::Provider",
+    "::Ice::Object"
+};
+
+bool
+Ehr::Provider::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(__Ehr__Provider_ids, __Ehr__Provider_ids + 2, _s);
+}
+
+::std::vector< ::std::string>
+Ehr::Provider::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&__Ehr__Provider_ids[0], &__Ehr__Provider_ids[2]);
+}
+
+const ::std::string&
+Ehr::Provider::ice_id(const ::Ice::Current&) const
+{
+    return __Ehr__Provider_ids[0];
+}
+
+const ::std::string&
+Ehr::Provider::ice_staticId()
+{
+    return __Ehr__Provider_ids[0];
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___createPrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::CreatePrescriptionRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    ::Ehr::Signature ownerSignature;
+    __is->read(::Ehr::__patch__CreatePrescriptionRequestPtr, &request);
+    requestorSignature.__read(__is);
+    ownerSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        createPrescription(request, requestorSignature, ownerSignature, __current);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___consumePrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::ConsumePrescriptionRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    ::Ehr::Signature ownerSignature;
+    __is->read(::Ehr::__patch__ConsumePrescriptionRequestPtr, &request);
+    requestorSignature.__read(__is);
+    ownerSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        consumePrescription(request, requestorSignature, ownerSignature, __current);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___listDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::ListDocumentsRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    ::Ehr::Signature ownerSignature;
+    __is->read(::Ehr::__patch__ListDocumentsRequestPtr, &request);
+    requestorSignature.__read(__is);
+    ownerSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        ::Ehr::DocumentList __ret = listDocuments(request, requestorSignature, ownerSignature, __current);
+        if(__ret.size() == 0)
+        {
+            __os->writeSize(0);
+        }
+        else
+        {
+            ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
+        }
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___findDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::FindDocumentsRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    ::Ehr::Signature ownerSignature;
+    __is->read(::Ehr::__patch__FindDocumentsRequestPtr, &request);
+    requestorSignature.__read(__is);
+    ownerSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        ::Ehr::DocumentList __ret = findDocuments(request, requestorSignature, ownerSignature, __current);
+        if(__ret.size() == 0)
+        {
+            __os->writeSize(0);
+        }
+        else
+        {
+            ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
+        }
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___setDefaultAccess(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::SetDefaultAccessRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    __is->read(::Ehr::__patch__SetDefaultAccessRequestPtr, &request);
+    requestorSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        setDefaultAccess(request, requestorSignature, __current);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___createPermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::CreatePermissionRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    __is->read(::Ehr::__patch__CreatePermissionRequestPtr, &request);
+    requestorSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        createPermission(request, requestorSignature, __current);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___listPermissions(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::ListPermissionsRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    __is->read(::Ehr::__patch__ListPermissionsRequestPtr, &request);
+    requestorSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        ::Ehr::Permissions __ret = listPermissions(request, requestorSignature, __current);
+        __ret.__write(__os);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+::Ice::DispatchStatus
+Ehr::Provider::___removePermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+{
+    __checkMode(::Ice::Normal, __current.mode);
+    ::IceInternal::BasicStream* __is = __inS.is();
+    __is->startReadEncaps();
+    ::Ehr::RemovePermissionRequestPtr request;
+    ::Ehr::Signature requestorSignature;
+    __is->read(::Ehr::__patch__RemovePermissionRequestPtr, &request);
+    requestorSignature.__read(__is);
+    __is->readPendingObjects();
+    __is->endReadEncaps();
+    ::IceInternal::BasicStream* __os = __inS.os();
+    try
+    {
+        removePermission(request, requestorSignature, __current);
+    }
+    catch(const ::Ehr::EhrException& __ex)
+    {
+        __os->write(__ex);
+        return ::Ice::DispatchUserException;
+    }
+    return ::Ice::DispatchOK;
+}
+
+static ::std::string __Ehr__Provider_all[] =
+{
+    "consumePrescription",
+    "createPermission",
+    "createPrescription",
+    "findDocuments",
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping",
+    "listDocuments",
+    "listPermissions",
+    "removePermission",
+    "setDefaultAccess"
+};
+
+::Ice::DispatchStatus
+Ehr::Provider::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+{
+    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Ehr__Provider_all, __Ehr__Provider_all + 12, current.operation);
+    if(r.first == r.second)
+    {
+        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }
+
+    switch(r.first - __Ehr__Provider_all)
+    {
+        case 0:
+        {
+            return ___consumePrescription(in, current);
+        }
+        case 1:
+        {
+            return ___createPermission(in, current);
+        }
+        case 2:
+        {
+            return ___createPrescription(in, current);
+        }
+        case 3:
+        {
+            return ___findDocuments(in, current);
+        }
+        case 4:
+        {
+            return ___ice_id(in, current);
+        }
+        case 5:
+        {
+            return ___ice_ids(in, current);
+        }
+        case 6:
+        {
+            return ___ice_isA(in, current);
+        }
+        case 7:
+        {
+            return ___ice_ping(in, current);
+        }
+        case 8:
+        {
+            return ___listDocuments(in, current);
+        }
+        case 9:
+        {
+            return ___listPermissions(in, current);
+        }
+        case 10:
+        {
+            return ___removePermission(in, current);
+        }
+        case 11:
+        {
+            return ___setDefaultAccess(in, current);
+        }
+    }
+
+    assert(false);
+    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+}
+
+void
+Ehr::Provider::__write(::IceInternal::BasicStream* __os) const
+{
+    __os->writeTypeId(ice_staticId());
+    __os->startWriteSlice();
+    __os->endWriteSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__os);
+#else
+    ::Ice::Object::__write(__os);
+#endif
+}
+
+void
+Ehr::Provider::__read(::IceInternal::BasicStream* __is, bool __rid)
+{
+    if(__rid)
+    {
+        ::std::string myId;
+        __is->readTypeId(myId);
+    }
+    __is->startReadSlice();
+    __is->endReadSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__is, true);
+#else
+    ::Ice::Object::__read(__is, true);
+#endif
+}
+
+void
+Ehr::Provider::__write(const ::Ice::OutputStreamPtr& __outS) const
+{
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__write(__outS);
+#else
+    ::Ice::Object::__write(__outS);
+#endif
+}
+
+void
+Ehr::Provider::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
+{
+    if(__rid)
+    {
+        __inS->readTypeId();
+    }
+    __inS->startSlice();
+    __inS->endSlice();
+#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
+    Object::__read(__inS, true);
+#else
+    ::Ice::Object::__read(__inS, true);
+#endif
+}
+
+void 
+Ehr::__patch__ProviderPtr(void* __addr, ::Ice::ObjectPtr& v)
+{
+    ::Ehr::ProviderPtr* p = static_cast< ::Ehr::ProviderPtr*>(__addr);
+    assert(p);
+    *p = ::Ehr::ProviderPtr::dynamicCast(v);
+    if(v && !*p)
+    {
+        IceInternal::Ex::throwUOE(::Ehr::Provider::ice_staticId(), v->ice_id());
+    }
+}
+
+bool
+Ehr::operator==(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
+{
+    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
+}
+
+bool
+Ehr::operator<(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
+{
+    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
+}