From 1d8445b8461f558987067d870f0f11cdc84b4f35 Mon Sep 17 00:00:00 2001 From: manuel Date: Sat, 31 Oct 2009 16:11:26 +0100 Subject: pushing task1 to repo --- task1/ehr.cpp | 6836 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6836 insertions(+) create mode 100644 task1/ehr.cpp (limited to 'task1/ehr.cpp') 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 +#include +#include +#include +#include +#include +#include + +#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(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 ___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(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 ___encryptedKey; + __is->read(___encryptedKey); + ::std::vector< ::Ice::Byte>(___encryptedKey.first, ___encryptedKey.second).swap(encryptedKey); + ::std::pair ___initialVector; + __is->read(___initialVector); + ::std::vector< ::Ice::Byte>(___initialVector.first, ___initialVector.second).swap(initialVector); + ::std::pair ___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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::Document& l, const ::Ehr::Document& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::Request& l, const ::Ehr::Request& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r) +{ + return static_cast(l) < static_cast(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(l) == static_cast(r); +} + +bool +Ehr::operator<(const ::Ehr::Provider& l, const ::Ehr::Provider& r) +{ + return static_cast(l) < static_cast(r); +} -- cgit v1.2.3