// **********************************************************************
//
// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.1
// Generated from file `ehr.ice'

#include <ehr.h>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/BasicStream.h>
#include <Ice/Stream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/ScopedArray.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

static const ::std::string __Ehr__Provider__createPrescription_name = "createPrescription";

static const ::std::string __Ehr__Provider__consumePrescription_name = "consumePrescription";

static const ::std::string __Ehr__Provider__listDocuments_name = "listDocuments";

static const ::std::string __Ehr__Provider__findDocuments_name = "findDocuments";

static const ::std::string __Ehr__Provider__setDefaultAccess_name = "setDefaultAccess";

static const ::std::string __Ehr__Provider__createPermission_name = "createPermission";

static const ::std::string __Ehr__Provider__listPermissions_name = "listPermissions";

static const ::std::string __Ehr__Provider__removePermission_name = "removePermission";

::Ice::Object* IceInternal::upCast(::Ehr::Document* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Document* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::Prescription* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Prescription* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::ConsumedPrescription* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumedPrescription* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::Request* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Request* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::ThirdPartyRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ThirdPartyRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::CreatePrescriptionRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePrescriptionRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::ConsumePrescriptionRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ConsumePrescriptionRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::ListDocumentsRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListDocumentsRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::FindDocumentsRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::FindDocumentsRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::CreatePermissionRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::CreatePermissionRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::SetDefaultAccessRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::SetDefaultAccessRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::ListPermissionsRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::ListPermissionsRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::RemovePermissionRequest* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::RemovePermissionRequest* p) { return p; }

::Ice::Object* IceInternal::upCast(::Ehr::Provider* p) { return p; }
::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Ehr::Provider* p) { return p; }

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Document;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeDocumentPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readDocumentPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Document;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__DocumentPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::PrescriptionPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Prescription;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writePrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Prescription;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writePrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::PrescriptionPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::PrescriptionPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__PrescriptionPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumedPrescriptionPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ConsumedPrescription;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeConsumedPrescriptionPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readConsumedPrescriptionPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ConsumedPrescription;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeConsumedPrescription(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumedPrescriptionPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readConsumedPrescription(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumedPrescriptionPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumedPrescriptionPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Request;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Request;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ThirdPartyRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ThirdPartyRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeThirdPartyRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readThirdPartyRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ThirdPartyRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeThirdPartyRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ThirdPartyRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readThirdPartyRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ThirdPartyRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ThirdPartyRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePrescriptionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeCreatePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readCreatePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::CreatePrescriptionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeCreatePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePrescriptionRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readCreatePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePrescriptionRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePrescriptionRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ConsumePrescriptionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeConsumePrescriptionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readConsumePrescriptionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ConsumePrescriptionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeConsumePrescriptionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ConsumePrescriptionRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readConsumePrescriptionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ConsumePrescriptionRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ConsumePrescriptionRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListDocumentsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ListDocumentsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeListDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readListDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ListDocumentsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeListDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListDocumentsRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readListDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListDocumentsRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListDocumentsRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::FindDocumentsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::FindDocumentsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeFindDocumentsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readFindDocumentsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::FindDocumentsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeFindDocumentsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::FindDocumentsRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readFindDocumentsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::FindDocumentsRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__FindDocumentsRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::CreatePermissionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::CreatePermissionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeCreatePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readCreatePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::CreatePermissionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeCreatePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::CreatePermissionRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readCreatePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::CreatePermissionRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__CreatePermissionRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::SetDefaultAccessRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeSetDefaultAccessRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readSetDefaultAccessRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::SetDefaultAccessRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeSetDefaultAccessRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::SetDefaultAccessRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readSetDefaultAccessRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::SetDefaultAccessRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__SetDefaultAccessRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ListPermissionsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ListPermissionsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeListPermissionsRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readListPermissionsRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::ListPermissionsRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeListPermissionsRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ListPermissionsRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readListPermissionsRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::ListPermissionsRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ListPermissionsRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::RemovePermissionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::RemovePermissionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeRemovePermissionRequestPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readRemovePermissionRequestPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::RemovePermissionRequest;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeRemovePermissionRequest(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::RemovePermissionRequestPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readRemovePermissionRequest(const ::Ice::InputStreamPtr& __inS, ::Ehr::RemovePermissionRequestPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__RemovePermissionRequestPtr, &__v);
    __inS->readObject(__cb);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::ProviderPrx& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Provider;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeProviderPrx(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPrx& v)
{
    __outS->writeProxy(v);
}

void
Ehr::ice_readProviderPrx(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPrx& v)
{
    ::Ice::ObjectPrx proxy = __inS->readProxy();
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Ehr::Provider;
        v->__copyFrom(proxy);
    }
}

void
Ehr::ice_writeProvider(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::ProviderPtr& v)
{
    __outS->writeObject(v);
}

void
Ehr::ice_readProvider(const ::Ice::InputStreamPtr& __inS, ::Ehr::ProviderPtr& __v)
{
    ::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(::Ehr::__patch__ProviderPtr, &__v);
    __inS->readObject(__cb);
}

Ehr::EhrException::EhrException(const ::std::string& __ice_what) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    UserException(),
#else
    ::Ice::UserException(),
#endif
    what(__ice_what)
{
}

Ehr::EhrException::~EhrException() throw()
{
}

static const char* __Ehr__EhrException_name = "Ehr::EhrException";

::std::string
Ehr::EhrException::ice_name() const
{
    return __Ehr__EhrException_name;
}

::Ice::Exception*
Ehr::EhrException::ice_clone() const
{
    return new EhrException(*this);
}

void
Ehr::EhrException::ice_throw() const
{
    throw *this;
}

void
Ehr::EhrException::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Ehr::EhrException"), false);
    __os->startWriteSlice();
    __os->write(what);
    __os->endWriteSlice();
}

void
Ehr::EhrException::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->read(what);
    __is->endReadSlice();
}

void
Ehr::EhrException::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(::std::string("::Ehr::EhrException"));
    __outS->startSlice();
    __outS->writeString(what);
    __outS->endSlice();
}

void
Ehr::EhrException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readString();
    }
    __inS->startSlice();
    what = __inS->readString();
    __inS->endSlice();
}

struct __F__Ehr__EhrException : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Ehr::EhrException();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__EhrException__Ptr = new __F__Ehr__EhrException;

const ::IceInternal::UserExceptionFactoryPtr&
Ehr::EhrException::ice_factory()
{
    return __F__Ehr__EhrException__Ptr;
}

class __F__Ehr__EhrException__Init
{
public:

    __F__Ehr__EhrException__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::EhrException", ::Ehr::EhrException::ice_factory());
    }

    ~__F__Ehr__EhrException__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::EhrException");
    }
};

static __F__Ehr__EhrException__Init __F__Ehr__EhrException__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__EhrException__initializer() {} }
#endif

Ehr::InvalidRequestException::InvalidRequestException(const ::std::string& __ice_what) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException(__ice_what)
#else
    ::Ehr::EhrException(__ice_what)
#endif
{
}

Ehr::InvalidRequestException::~InvalidRequestException() throw()
{
}

static const char* __Ehr__InvalidRequestException_name = "Ehr::InvalidRequestException";

::std::string
Ehr::InvalidRequestException::ice_name() const
{
    return __Ehr__InvalidRequestException_name;
}

::Ice::Exception*
Ehr::InvalidRequestException::ice_clone() const
{
    return new InvalidRequestException(*this);
}

void
Ehr::InvalidRequestException::ice_throw() const
{
    throw *this;
}

void
Ehr::InvalidRequestException::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Ehr::InvalidRequestException"), false);
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__os);
#else
    ::Ehr::EhrException::__write(__os);
#endif
}

void
Ehr::InvalidRequestException::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__is, true);
#else
    ::Ehr::EhrException::__read(__is, true);
#endif
}

void
Ehr::InvalidRequestException::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(::std::string("::Ehr::InvalidRequestException"));
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__outS);
#else
    ::Ehr::EhrException::__write(__outS);
#endif
}

void
Ehr::InvalidRequestException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readString();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__inS, true);
#else
    ::Ehr::EhrException::__read(__inS, true);
#endif
}

struct __F__Ehr__InvalidRequestException : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Ehr::InvalidRequestException();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidRequestException__Ptr = new __F__Ehr__InvalidRequestException;

const ::IceInternal::UserExceptionFactoryPtr&
Ehr::InvalidRequestException::ice_factory()
{
    return __F__Ehr__InvalidRequestException__Ptr;
}

class __F__Ehr__InvalidRequestException__Init
{
public:

    __F__Ehr__InvalidRequestException__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidRequestException", ::Ehr::InvalidRequestException::ice_factory());
    }

    ~__F__Ehr__InvalidRequestException__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidRequestException");
    }
};

static __F__Ehr__InvalidRequestException__Init __F__Ehr__InvalidRequestException__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__InvalidRequestException__initializer() {} }
#endif

Ehr::InvalidAccountException::InvalidAccountException(const ::std::string& __ice_what) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    InvalidRequestException(__ice_what)
#else
    ::Ehr::InvalidRequestException(__ice_what)
#endif
{
}

Ehr::InvalidAccountException::~InvalidAccountException() throw()
{
}

static const char* __Ehr__InvalidAccountException_name = "Ehr::InvalidAccountException";

::std::string
Ehr::InvalidAccountException::ice_name() const
{
    return __Ehr__InvalidAccountException_name;
}

::Ice::Exception*
Ehr::InvalidAccountException::ice_clone() const
{
    return new InvalidAccountException(*this);
}

void
Ehr::InvalidAccountException::ice_throw() const
{
    throw *this;
}

void
Ehr::InvalidAccountException::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Ehr::InvalidAccountException"), false);
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    InvalidRequestException::__write(__os);
#else
    ::Ehr::InvalidRequestException::__write(__os);
#endif
}

void
Ehr::InvalidAccountException::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    InvalidRequestException::__read(__is, true);
#else
    ::Ehr::InvalidRequestException::__read(__is, true);
#endif
}

void
Ehr::InvalidAccountException::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(::std::string("::Ehr::InvalidAccountException"));
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    InvalidRequestException::__write(__outS);
#else
    ::Ehr::InvalidRequestException::__write(__outS);
#endif
}

void
Ehr::InvalidAccountException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readString();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    InvalidRequestException::__read(__inS, true);
#else
    ::Ehr::InvalidRequestException::__read(__inS, true);
#endif
}

struct __F__Ehr__InvalidAccountException : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Ehr::InvalidAccountException();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__InvalidAccountException__Ptr = new __F__Ehr__InvalidAccountException;

const ::IceInternal::UserExceptionFactoryPtr&
Ehr::InvalidAccountException::ice_factory()
{
    return __F__Ehr__InvalidAccountException__Ptr;
}

class __F__Ehr__InvalidAccountException__Init
{
public:

    __F__Ehr__InvalidAccountException__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::InvalidAccountException", ::Ehr::InvalidAccountException::ice_factory());
    }

    ~__F__Ehr__InvalidAccountException__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::InvalidAccountException");
    }
};

static __F__Ehr__InvalidAccountException__Init __F__Ehr__InvalidAccountException__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__InvalidAccountException__initializer() {} }
#endif

Ehr::SignatureException::SignatureException(const ::std::string& __ice_what) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException(__ice_what)
#else
    ::Ehr::EhrException(__ice_what)
#endif
{
}

Ehr::SignatureException::~SignatureException() throw()
{
}

static const char* __Ehr__SignatureException_name = "Ehr::SignatureException";

::std::string
Ehr::SignatureException::ice_name() const
{
    return __Ehr__SignatureException_name;
}

::Ice::Exception*
Ehr::SignatureException::ice_clone() const
{
    return new SignatureException(*this);
}

void
Ehr::SignatureException::ice_throw() const
{
    throw *this;
}

void
Ehr::SignatureException::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Ehr::SignatureException"), false);
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__os);
#else
    ::Ehr::EhrException::__write(__os);
#endif
}

void
Ehr::SignatureException::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__is, true);
#else
    ::Ehr::EhrException::__read(__is, true);
#endif
}

void
Ehr::SignatureException::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(::std::string("::Ehr::SignatureException"));
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__outS);
#else
    ::Ehr::EhrException::__write(__outS);
#endif
}

void
Ehr::SignatureException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readString();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__inS, true);
#else
    ::Ehr::EhrException::__read(__inS, true);
#endif
}

struct __F__Ehr__SignatureException : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Ehr::SignatureException();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__SignatureException__Ptr = new __F__Ehr__SignatureException;

const ::IceInternal::UserExceptionFactoryPtr&
Ehr::SignatureException::ice_factory()
{
    return __F__Ehr__SignatureException__Ptr;
}

class __F__Ehr__SignatureException__Init
{
public:

    __F__Ehr__SignatureException__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::SignatureException", ::Ehr::SignatureException::ice_factory());
    }

    ~__F__Ehr__SignatureException__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::SignatureException");
    }
};

static __F__Ehr__SignatureException__Init __F__Ehr__SignatureException__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__SignatureException__initializer() {} }
#endif

Ehr::PermissionDeniedException::PermissionDeniedException(const ::std::string& __ice_what) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException(__ice_what)
#else
    ::Ehr::EhrException(__ice_what)
#endif
{
}

Ehr::PermissionDeniedException::~PermissionDeniedException() throw()
{
}

static const char* __Ehr__PermissionDeniedException_name = "Ehr::PermissionDeniedException";

::std::string
Ehr::PermissionDeniedException::ice_name() const
{
    return __Ehr__PermissionDeniedException_name;
}

::Ice::Exception*
Ehr::PermissionDeniedException::ice_clone() const
{
    return new PermissionDeniedException(*this);
}

void
Ehr::PermissionDeniedException::ice_throw() const
{
    throw *this;
}

void
Ehr::PermissionDeniedException::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(::std::string("::Ehr::PermissionDeniedException"), false);
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__os);
#else
    ::Ehr::EhrException::__write(__os);
#endif
}

void
Ehr::PermissionDeniedException::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->read(myId, false);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__is, true);
#else
    ::Ehr::EhrException::__read(__is, true);
#endif
}

void
Ehr::PermissionDeniedException::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(::std::string("::Ehr::PermissionDeniedException"));
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__write(__outS);
#else
    ::Ehr::EhrException::__write(__outS);
#endif
}

void
Ehr::PermissionDeniedException::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readString();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    EhrException::__read(__inS, true);
#else
    ::Ehr::EhrException::__read(__inS, true);
#endif
}

struct __F__Ehr__PermissionDeniedException : public ::IceInternal::UserExceptionFactory
{
    virtual void
    createAndThrow()
    {
        throw ::Ehr::PermissionDeniedException();
    }
};

static ::IceInternal::UserExceptionFactoryPtr __F__Ehr__PermissionDeniedException__Ptr = new __F__Ehr__PermissionDeniedException;

const ::IceInternal::UserExceptionFactoryPtr&
Ehr::PermissionDeniedException::ice_factory()
{
    return __F__Ehr__PermissionDeniedException__Ptr;
}

class __F__Ehr__PermissionDeniedException__Init
{
public:

    __F__Ehr__PermissionDeniedException__Init()
    {
        ::IceInternal::factoryTable->addExceptionFactory("::Ehr::PermissionDeniedException", ::Ehr::PermissionDeniedException::ice_factory());
    }

    ~__F__Ehr__PermissionDeniedException__Init()
    {
        ::IceInternal::factoryTable->removeExceptionFactory("::Ehr::PermissionDeniedException");
    }
};

static __F__Ehr__PermissionDeniedException__Init __F__Ehr__PermissionDeniedException__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__PermissionDeniedException__initializer() {} }
#endif

bool
Ehr::AccountIdentifier::operator==(const AccountIdentifier& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(user != __rhs.user)
    {
        return false;
    }
    if(provider != __rhs.provider)
    {
        return false;
    }
    return true;
}

bool
Ehr::AccountIdentifier::operator<(const AccountIdentifier& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(user < __rhs.user)
    {
        return true;
    }
    else if(__rhs.user < user)
    {
        return false;
    }
    if(provider < __rhs.provider)
    {
        return true;
    }
    else if(__rhs.provider < provider)
    {
        return false;
    }
    return false;
}

void
Ehr::AccountIdentifier::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(user);
    __os->write(provider);
}

void
Ehr::AccountIdentifier::__read(::IceInternal::BasicStream* __is)
{
    __is->read(user);
    __is->read(provider);
}

void
Ehr::AccountIdentifier::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeString(user);
    __outS->writeString(provider);
}

void
Ehr::AccountIdentifier::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    user = __inS->readString();
    provider = __inS->readString();
}

void
Ehr::ice_writeAccountIdentifier(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccountIdentifier& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readAccountIdentifier(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccountIdentifier& __v)
{
    __v.ice_read(__inS);
}

void
Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::DocumentType v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 3);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::DocumentType& v)
{
    ::Ice::Byte val;
    __is->read(val, 3);
    v = static_cast< ::Ehr::DocumentType>(val);
}

void
Ehr::ice_writeDocumentType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::DocumentType v)
{
    if(static_cast<int>(v) >= 3)
    {
        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
    }
    __outS->writeByte(static_cast< ::Ice::Byte>(v));
}

void
Ehr::ice_readDocumentType(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentType& v)
{
    ::Ice::Byte val = __inS->readByte();
    if(val > 3)
    {
        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
    }
    v = static_cast< ::Ehr::DocumentType>(val);
}

bool
Ehr::Signature::operator==(const Signature& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(data != __rhs.data)
    {
        return false;
    }
    return true;
}

bool
Ehr::Signature::operator<(const Signature& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(data < __rhs.data)
    {
        return true;
    }
    else if(__rhs.data < data)
    {
        return false;
    }
    return false;
}

void
Ehr::Signature::__write(::IceInternal::BasicStream* __os) const
{
    if(data.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&data[0], &data[0] + data.size());
    }
}

void
Ehr::Signature::__read(::IceInternal::BasicStream* __is)
{
    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___data;
    __is->read(___data);
    ::std::vector< ::Ice::Byte>(___data.first, ___data.second).swap(data);
}

void
Ehr::Signature::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeByteSeq(data);
}

void
Ehr::Signature::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    data = __inS->readByteSeq();
}

void
Ehr::ice_writeSignature(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Signature& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readSignature(const ::Ice::InputStreamPtr& __inS, ::Ehr::Signature& __v)
{
    __v.ice_read(__inS);
}

bool
Ehr::Timestamp::operator==(const Timestamp& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(msecs != __rhs.msecs)
    {
        return false;
    }
    return true;
}

bool
Ehr::Timestamp::operator<(const Timestamp& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(msecs < __rhs.msecs)
    {
        return true;
    }
    else if(__rhs.msecs < msecs)
    {
        return false;
    }
    return false;
}

void
Ehr::Timestamp::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(msecs);
}

void
Ehr::Timestamp::__read(::IceInternal::BasicStream* __is)
{
    __is->read(msecs);
}

void
Ehr::Timestamp::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeLong(msecs);
}

void
Ehr::Timestamp::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    msecs = __inS->readLong();
}

void
Ehr::ice_writeTimestamp(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Timestamp& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readTimestamp(const ::Ice::InputStreamPtr& __inS, ::Ehr::Timestamp& __v)
{
    __v.ice_read(__inS);
}

bool
Ehr::Date::operator==(const Date& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(day != __rhs.day)
    {
        return false;
    }
    if(month != __rhs.month)
    {
        return false;
    }
    if(year != __rhs.year)
    {
        return false;
    }
    return true;
}

bool
Ehr::Date::operator<(const Date& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(day < __rhs.day)
    {
        return true;
    }
    else if(__rhs.day < day)
    {
        return false;
    }
    if(month < __rhs.month)
    {
        return true;
    }
    else if(__rhs.month < month)
    {
        return false;
    }
    if(year < __rhs.year)
    {
        return true;
    }
    else if(__rhs.year < year)
    {
        return false;
    }
    return false;
}

void
Ehr::Date::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(day);
    __os->write(month);
    __os->write(year);
}

void
Ehr::Date::__read(::IceInternal::BasicStream* __is)
{
    __is->read(day);
    __is->read(month);
    __is->read(year);
}

void
Ehr::Date::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeByte(day);
    __outS->writeByte(month);
    __outS->writeShort(year);
}

void
Ehr::Date::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    day = __inS->readByte();
    month = __inS->readByte();
    year = __inS->readShort();
}

void
Ehr::ice_writeDate(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Date& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readDate(const ::Ice::InputStreamPtr& __inS, ::Ehr::Date& __v)
{
    __v.ice_read(__inS);
}

void
Ehr::__write(::IceInternal::BasicStream* __os, ::Ehr::AccessType v)
{
    __os->write(static_cast< ::Ice::Byte>(v), 2);
}

void
Ehr::__read(::IceInternal::BasicStream* __is, ::Ehr::AccessType& v)
{
    ::Ice::Byte val;
    __is->read(val, 2);
    v = static_cast< ::Ehr::AccessType>(val);
}

void
Ehr::ice_writeAccessType(const ::Ice::OutputStreamPtr& __outS, ::Ehr::AccessType v)
{
    if(static_cast<int>(v) >= 2)
    {
        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
    }
    __outS->writeByte(static_cast< ::Ice::Byte>(v));
}

void
Ehr::ice_readAccessType(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessType& v)
{
    ::Ice::Byte val = __inS->readByte();
    if(val > 2)
    {
        throw ::Ice::MarshalException(__FILE__, __LINE__, "enumerator out of range");
    }
    v = static_cast< ::Ehr::AccessType>(val);
}

bool
Ehr::EncryptedDocument::operator==(const EncryptedDocument& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(encryptedKey != __rhs.encryptedKey)
    {
        return false;
    }
    if(initialVector != __rhs.initialVector)
    {
        return false;
    }
    if(encryptedData != __rhs.encryptedData)
    {
        return false;
    }
    return true;
}

bool
Ehr::EncryptedDocument::operator<(const EncryptedDocument& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(encryptedKey < __rhs.encryptedKey)
    {
        return true;
    }
    else if(__rhs.encryptedKey < encryptedKey)
    {
        return false;
    }
    if(initialVector < __rhs.initialVector)
    {
        return true;
    }
    else if(__rhs.initialVector < initialVector)
    {
        return false;
    }
    if(encryptedData < __rhs.encryptedData)
    {
        return true;
    }
    else if(__rhs.encryptedData < encryptedData)
    {
        return false;
    }
    return false;
}

void
Ehr::EncryptedDocument::__write(::IceInternal::BasicStream* __os) const
{
    if(encryptedKey.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&encryptedKey[0], &encryptedKey[0] + encryptedKey.size());
    }
    if(initialVector.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&initialVector[0], &initialVector[0] + initialVector.size());
    }
    if(encryptedData.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        __os->write(&encryptedData[0], &encryptedData[0] + encryptedData.size());
    }
}

void
Ehr::EncryptedDocument::__read(::IceInternal::BasicStream* __is)
{
    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedKey;
    __is->read(___encryptedKey);
    ::std::vector< ::Ice::Byte>(___encryptedKey.first, ___encryptedKey.second).swap(encryptedKey);
    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___initialVector;
    __is->read(___initialVector);
    ::std::vector< ::Ice::Byte>(___initialVector.first, ___initialVector.second).swap(initialVector);
    ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> ___encryptedData;
    __is->read(___encryptedData);
    ::std::vector< ::Ice::Byte>(___encryptedData.first, ___encryptedData.second).swap(encryptedData);
}

void
Ehr::EncryptedDocument::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeByteSeq(encryptedKey);
    __outS->writeByteSeq(initialVector);
    __outS->writeByteSeq(encryptedData);
}

void
Ehr::EncryptedDocument::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    encryptedKey = __inS->readByteSeq();
    initialVector = __inS->readByteSeq();
    encryptedData = __inS->readByteSeq();
}

void
Ehr::ice_writeEncryptedDocument(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::EncryptedDocument& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readEncryptedDocument(const ::Ice::InputStreamPtr& __inS, ::Ehr::EncryptedDocument& __v)
{
    __v.ice_read(__inS);
}

bool
Ehr::DocumentListItem::operator==(const DocumentListItem& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(id != __rhs.id)
    {
        return false;
    }
    if(created != __rhs.created)
    {
        return false;
    }
    if(document != __rhs.document)
    {
        return false;
    }
    return true;
}

bool
Ehr::DocumentListItem::operator<(const DocumentListItem& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(id < __rhs.id)
    {
        return true;
    }
    else if(__rhs.id < id)
    {
        return false;
    }
    if(created < __rhs.created)
    {
        return true;
    }
    else if(__rhs.created < created)
    {
        return false;
    }
    if(document < __rhs.document)
    {
        return true;
    }
    else if(__rhs.document < document)
    {
        return false;
    }
    return false;
}

void
Ehr::DocumentListItem::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(id);
    created.__write(__os);
    document.__write(__os);
}

void
Ehr::DocumentListItem::__read(::IceInternal::BasicStream* __is)
{
    __is->read(id);
    created.__read(__is);
    document.__read(__is);
}

void
Ehr::DocumentListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeLong(id);
    ::Ehr::ice_writeTimestamp(__outS, created);
    ::Ehr::ice_writeEncryptedDocument(__outS, document);
}

void
Ehr::DocumentListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    id = __inS->readLong();
    ::Ehr::ice_readTimestamp(__inS, created);
    ::Ehr::ice_readEncryptedDocument(__inS, document);
}

void
Ehr::ice_writeDocumentListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentListItem& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readDocumentListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentListItem& __v)
{
    __v.ice_read(__inS);
}

void
Ehr::__writeDocumentList(::IceInternal::BasicStream* __os, const ::Ehr::DocumentListItem* begin, const ::Ehr::DocumentListItem* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
Ehr::__readDocumentList(::IceInternal::BasicStream* __is, ::Ehr::DocumentList& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 19);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

void
Ehr::ice_writeDocumentList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::DocumentList& v)
{
    __outS->writeSize(::Ice::Int(v.size()));
    ::Ehr::DocumentList::const_iterator p;
    for(p = v.begin(); p != v.end(); ++p)
    {
        ::Ehr::ice_writeDocumentListItem(__outS, (*p));
    }
}

void
Ehr::ice_readDocumentList(const ::Ice::InputStreamPtr& __inS, ::Ehr::DocumentList& v)
{
    ::Ice::Int sz = __inS->readSize();
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        ::Ehr::ice_readDocumentListItem(__inS, v[i]);
    }
}

bool
Ehr::AccessControlListItem::operator==(const AccessControlListItem& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(id != __rhs.id)
    {
        return false;
    }
    if(account != __rhs.account)
    {
        return false;
    }
    if(access != __rhs.access)
    {
        return false;
    }
    return true;
}

bool
Ehr::AccessControlListItem::operator<(const AccessControlListItem& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(id < __rhs.id)
    {
        return true;
    }
    else if(__rhs.id < id)
    {
        return false;
    }
    if(account < __rhs.account)
    {
        return true;
    }
    else if(__rhs.account < account)
    {
        return false;
    }
    if(access < __rhs.access)
    {
        return true;
    }
    else if(__rhs.access < access)
    {
        return false;
    }
    return false;
}

void
Ehr::AccessControlListItem::__write(::IceInternal::BasicStream* __os) const
{
    __os->write(id);
    account.__write(__os);
    ::Ehr::__write(__os, access);
}

void
Ehr::AccessControlListItem::__read(::IceInternal::BasicStream* __is)
{
    __is->read(id);
    account.__read(__is);
    ::Ehr::__read(__is, access);
}

void
Ehr::AccessControlListItem::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeLong(id);
    ::Ehr::ice_writeAccountIdentifier(__outS, account);
    ::Ehr::ice_writeAccessType(__outS, access);
}

void
Ehr::AccessControlListItem::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    id = __inS->readLong();
    ::Ehr::ice_readAccountIdentifier(__inS, account);
    ::Ehr::ice_readAccessType(__inS, access);
}

void
Ehr::ice_writeAccessControlListItem(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlListItem& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readAccessControlListItem(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlListItem& __v)
{
    __v.ice_read(__inS);
}

void
Ehr::__writeAccessControlList(::IceInternal::BasicStream* __os, const ::Ehr::AccessControlListItem* begin, const ::Ehr::AccessControlListItem* end)
{
    ::Ice::Int size = static_cast< ::Ice::Int>(end - begin);
    __os->writeSize(size);
    for(int i = 0; i < size; ++i)
    {
        begin[i].__write(__os);
    }
}

void
Ehr::__readAccessControlList(::IceInternal::BasicStream* __is, ::Ehr::AccessControlList& v)
{
    ::Ice::Int sz;
    __is->readSize(sz);
    __is->startSeq(sz, 11);
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        v[i].__read(__is);
        __is->checkSeq();
        __is->endElement();
    }
    __is->endSeq(sz);
}

void
Ehr::ice_writeAccessControlList(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::AccessControlList& v)
{
    __outS->writeSize(::Ice::Int(v.size()));
    ::Ehr::AccessControlList::const_iterator p;
    for(p = v.begin(); p != v.end(); ++p)
    {
        ::Ehr::ice_writeAccessControlListItem(__outS, (*p));
    }
}

void
Ehr::ice_readAccessControlList(const ::Ice::InputStreamPtr& __inS, ::Ehr::AccessControlList& v)
{
    ::Ice::Int sz = __inS->readSize();
    v.resize(sz);
    for(int i = 0; i < sz; ++i)
    {
        ::Ehr::ice_readAccessControlListItem(__inS, v[i]);
    }
}

bool
Ehr::Permissions::operator==(const Permissions& __rhs) const
{
    if(this == &__rhs)
    {
        return true;
    }
    if(defaultAccess != __rhs.defaultAccess)
    {
        return false;
    }
    if(acl != __rhs.acl)
    {
        return false;
    }
    return true;
}

bool
Ehr::Permissions::operator<(const Permissions& __rhs) const
{
    if(this == &__rhs)
    {
        return false;
    }
    if(defaultAccess < __rhs.defaultAccess)
    {
        return true;
    }
    else if(__rhs.defaultAccess < defaultAccess)
    {
        return false;
    }
    if(acl < __rhs.acl)
    {
        return true;
    }
    else if(__rhs.acl < acl)
    {
        return false;
    }
    return false;
}

void
Ehr::Permissions::__write(::IceInternal::BasicStream* __os) const
{
    ::Ehr::__write(__os, defaultAccess);
    if(acl.size() == 0)
    {
        __os->writeSize(0);
    }
    else
    {
        ::Ehr::__writeAccessControlList(__os, &acl[0], &acl[0] + acl.size());
    }
}

void
Ehr::Permissions::__read(::IceInternal::BasicStream* __is)
{
    ::Ehr::__read(__is, defaultAccess);
    ::Ehr::__readAccessControlList(__is, acl);
}

void
Ehr::Permissions::ice_write(const ::Ice::OutputStreamPtr& __outS) const
{
    ::Ehr::ice_writeAccessType(__outS, defaultAccess);
    ::Ehr::ice_writeAccessControlList(__outS, acl);
}

void
Ehr::Permissions::ice_read(const ::Ice::InputStreamPtr& __inS)
{
    ::Ehr::ice_readAccessType(__inS, defaultAccess);
    ::Ehr::ice_readAccessControlList(__inS, acl);
}

void
Ehr::ice_writePermissions(const ::Ice::OutputStreamPtr& __outS, const ::Ehr::Permissions& __v)
{
    __v.ice_write(__outS);
}

void
Ehr::ice_readPermissions(const ::Ice::InputStreamPtr& __inS, ::Ehr::Permissions& __v)
{
    __v.ice_read(__inS);
}

const ::std::string&
IceProxy::Ehr::Document::ice_staticId()
{
    return ::Ehr::Document::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::Document::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Document);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::Document::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Document);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::Document::__newInstance() const
{
    return new Document;
}

const ::std::string&
IceProxy::Ehr::Prescription::ice_staticId()
{
    return ::Ehr::Prescription::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::Prescription::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Prescription);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::Prescription::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Prescription);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::Prescription::__newInstance() const
{
    return new Prescription;
}

const ::std::string&
IceProxy::Ehr::ConsumedPrescription::ice_staticId()
{
    return ::Ehr::ConsumedPrescription::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::ConsumedPrescription::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumedPrescription);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::ConsumedPrescription::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumedPrescription);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::ConsumedPrescription::__newInstance() const
{
    return new ConsumedPrescription;
}

const ::std::string&
IceProxy::Ehr::Request::ice_staticId()
{
    return ::Ehr::Request::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::Request::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Request);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::Request::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Request);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::Request::__newInstance() const
{
    return new Request;
}

const ::std::string&
IceProxy::Ehr::ThirdPartyRequest::ice_staticId()
{
    return ::Ehr::ThirdPartyRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::ThirdPartyRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ThirdPartyRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::ThirdPartyRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ThirdPartyRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::ThirdPartyRequest::__newInstance() const
{
    return new ThirdPartyRequest;
}

const ::std::string&
IceProxy::Ehr::CreatePrescriptionRequest::ice_staticId()
{
    return ::Ehr::CreatePrescriptionRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePrescriptionRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::CreatePrescriptionRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePrescriptionRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::CreatePrescriptionRequest::__newInstance() const
{
    return new CreatePrescriptionRequest;
}

const ::std::string&
IceProxy::Ehr::ConsumePrescriptionRequest::ice_staticId()
{
    return ::Ehr::ConsumePrescriptionRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ConsumePrescriptionRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::ConsumePrescriptionRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ConsumePrescriptionRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::ConsumePrescriptionRequest::__newInstance() const
{
    return new ConsumePrescriptionRequest;
}

const ::std::string&
IceProxy::Ehr::ListDocumentsRequest::ice_staticId()
{
    return ::Ehr::ListDocumentsRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::ListDocumentsRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListDocumentsRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::ListDocumentsRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListDocumentsRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::ListDocumentsRequest::__newInstance() const
{
    return new ListDocumentsRequest;
}

const ::std::string&
IceProxy::Ehr::FindDocumentsRequest::ice_staticId()
{
    return ::Ehr::FindDocumentsRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::FindDocumentsRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::FindDocumentsRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::FindDocumentsRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::FindDocumentsRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::FindDocumentsRequest::__newInstance() const
{
    return new FindDocumentsRequest;
}

const ::std::string&
IceProxy::Ehr::CreatePermissionRequest::ice_staticId()
{
    return ::Ehr::CreatePermissionRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::CreatePermissionRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::CreatePermissionRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::CreatePermissionRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::CreatePermissionRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::CreatePermissionRequest::__newInstance() const
{
    return new CreatePermissionRequest;
}

const ::std::string&
IceProxy::Ehr::SetDefaultAccessRequest::ice_staticId()
{
    return ::Ehr::SetDefaultAccessRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::SetDefaultAccessRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::SetDefaultAccessRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::SetDefaultAccessRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::SetDefaultAccessRequest::__newInstance() const
{
    return new SetDefaultAccessRequest;
}

const ::std::string&
IceProxy::Ehr::ListPermissionsRequest::ice_staticId()
{
    return ::Ehr::ListPermissionsRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::ListPermissionsRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::ListPermissionsRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::ListPermissionsRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::ListPermissionsRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::ListPermissionsRequest::__newInstance() const
{
    return new ListPermissionsRequest;
}

const ::std::string&
IceProxy::Ehr::RemovePermissionRequest::ice_staticId()
{
    return ::Ehr::RemovePermissionRequest::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::RemovePermissionRequest::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::RemovePermissionRequest);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::RemovePermissionRequest::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::RemovePermissionRequest);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::RemovePermissionRequest::__newInstance() const
{
    return new RemovePermissionRequest;
}

void
IceProxy::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__createPrescription_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            __del->createPrescription(request, requestorSignature, ownerSignature, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__consumePrescription_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            __del->consumePrescription(request, requestorSignature, ownerSignature, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ehr::DocumentList
IceProxy::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__listDocuments_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            return __del->listDocuments(request, requestorSignature, ownerSignature, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ehr::DocumentList
IceProxy::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__findDocuments_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            return __del->findDocuments(request, requestorSignature, ownerSignature, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__setDefaultAccess_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            __del->setDefaultAccess(request, requestorSignature, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__createPermission_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            __del->createPermission(request, requestorSignature, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

::Ehr::Permissions
IceProxy::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__listPermissions_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            return __del->listPermissions(request, requestorSignature, __ctx);
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

void
IceProxy::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
#if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
            IceUtil::DummyBCC dummy;
#endif
            __checkTwowayOnly(__Ehr__Provider__removePermission_name);
            __delBase = __getDelegate(false);
            ::IceDelegate::Ehr::Provider* __del = dynamic_cast< ::IceDelegate::Ehr::Provider*>(__delBase.get());
            __del->removePermission(request, requestorSignature, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex, 0);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, 0, __cnt);
        }
    }
}

const ::std::string&
IceProxy::Ehr::Provider::ice_staticId()
{
    return ::Ehr::Provider::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Ehr::Provider::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Ehr::Provider);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Ehr::Provider::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Ehr::Provider);
}

::IceProxy::Ice::Object*
IceProxy::Ehr::Provider::__newInstance() const
{
    return new Provider;
}

void
IceDelegateM::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        ownerSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        __og.is()->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        ownerSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        __og.is()->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ehr::DocumentList
IceDelegateM::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        ownerSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ehr::DocumentList __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::Ehr::__readDocumentList(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ehr::DocumentList
IceDelegateM::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        ownerSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ehr::DocumentList __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        ::Ehr::__readDocumentList(__is, __ret);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        __og.is()->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        __og.is()->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

::Ehr::Permissions
IceDelegateM::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    ::Ehr::Permissions __ret;
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        ::IceInternal::BasicStream* __is = __og.is();
        __is->startReadEncaps();
        __ret.__read(__is);
        __is->endReadEncaps();
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__handler.get(), __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(::Ice::ObjectPtr(::IceInternal::upCast(request.get())));
        requestorSignature.__write(__os);
        __os->writePendingObjects();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        if(!__ok)
        {
            try
            {
                __og.throwUserException();
            }
            catch(const ::Ehr::EhrException&)
            {
                throw;
            }
            catch(const ::Ice::UserException& __ex)
            {
                ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
                throw __uue;
            }
        }
        __og.is()->skipEmptyEncaps();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateD::Ehr::Provider::createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_request(request),
            _m_requestorSignature(requestorSignature),
            _m_ownerSignature(ownerSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->createPrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        const ::Ehr::CreatePrescriptionRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
        const ::Ehr::Signature& _m_ownerSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__createPrescription_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(request, requestorSignature, ownerSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

void
IceDelegateD::Ehr::Provider::consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_request(request),
            _m_requestorSignature(requestorSignature),
            _m_ownerSignature(ownerSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->consumePrescription(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        const ::Ehr::ConsumePrescriptionRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
        const ::Ehr::Signature& _m_ownerSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__consumePrescription_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(request, requestorSignature, ownerSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ehr::DocumentList
IceDelegateD::Ehr::Provider::listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ehr::DocumentList& __result, const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_request(request),
            _m_requestorSignature(requestorSignature),
            _m_ownerSignature(ownerSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->listDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::Ehr::DocumentList& _result;
        const ::Ehr::ListDocumentsRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
        const ::Ehr::Signature& _m_ownerSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__listDocuments_name, ::Ice::Normal, __context);
    ::Ehr::DocumentList __result;
    try
    {
        _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

::Ehr::DocumentList
IceDelegateD::Ehr::Provider::findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ehr::DocumentList& __result, const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_request(request),
            _m_requestorSignature(requestorSignature),
            _m_ownerSignature(ownerSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->findDocuments(_m_request, _m_requestorSignature, _m_ownerSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::Ehr::DocumentList& _result;
        const ::Ehr::FindDocumentsRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
        const ::Ehr::Signature& _m_ownerSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__findDocuments_name, ::Ice::Normal, __context);
    ::Ehr::DocumentList __result;
    try
    {
        _DirectI __direct(__result, request, requestorSignature, ownerSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::Ehr::Provider::setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_request(request),
            _m_requestorSignature(requestorSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->setDefaultAccess(_m_request, _m_requestorSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        const ::Ehr::SetDefaultAccessRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__setDefaultAccess_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(request, requestorSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

void
IceDelegateD::Ehr::Provider::createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_request(request),
            _m_requestorSignature(requestorSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->createPermission(_m_request, _m_requestorSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        const ::Ehr::CreatePermissionRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__createPermission_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(request, requestorSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

::Ehr::Permissions
IceDelegateD::Ehr::Provider::listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(::Ehr::Permissions& __result, const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _result(__result),
            _m_request(request),
            _m_requestorSignature(requestorSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                _result = servant->listPermissions(_m_request, _m_requestorSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        ::Ehr::Permissions& _result;
        const ::Ehr::ListPermissionsRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__listPermissions_name, ::Ice::Normal, __context);
    ::Ehr::Permissions __result;
    try
    {
        _DirectI __direct(__result, request, requestorSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
    return __result;
}

void
IceDelegateD::Ehr::Provider::removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context* __context)
{
    class _DirectI : public ::IceInternal::Direct
    {
    public:

        _DirectI(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Current& __current) : 
            ::IceInternal::Direct(__current),
            _m_request(request),
            _m_requestorSignature(requestorSignature)
        {
        }
        
        virtual ::Ice::DispatchStatus
        run(::Ice::Object* object)
        {
            ::Ehr::Provider* servant = dynamic_cast< ::Ehr::Provider*>(object);
            if(!servant)
            {
                throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
            }
            try
            {
                servant->removePermission(_m_request, _m_requestorSignature, _current);
                return ::Ice::DispatchOK;
            }
            catch(const ::Ice::UserException& __ex)
            {
                setUserException(__ex);
                return ::Ice::DispatchUserException;
            }
        }
        
    private:
        
        const ::Ehr::RemovePermissionRequestPtr& _m_request;
        const ::Ehr::Signature& _m_requestorSignature;
    };
    
    ::Ice::Current __current;
    __initCurrent(__current, __Ehr__Provider__removePermission_name, ::Ice::Normal, __context);
    try
    {
        _DirectI __direct(request, requestorSignature, __current);
        try
        {
            __direct.servant()->__collocDispatch(__direct);
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
    }
    catch(const ::Ehr::EhrException&)
    {
        throw;
    }
    catch(const ::Ice::SystemException&)
    {
        throw;
    }
    catch(const ::IceInternal::LocalExceptionWrapper&)
    {
        throw;
    }
    catch(const ::std::exception& __ex)
    {
        ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
    }
    catch(...)
    {
        throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
    }
}

Ehr::Document::Document(::Ehr::DocumentType __ice_type) :
    type(__ice_type)
{
}

::Ice::ObjectPtr
Ehr::Document::ice_clone() const
{
    ::Ehr::DocumentPtr __p = new ::Ehr::Document(*this);
    return __p;
}

static const ::std::string __Ehr__Document_ids[2] =
{
    "::Ehr::Document",
    "::Ice::Object"
};

bool
Ehr::Document::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__Document_ids, __Ehr__Document_ids + 2, _s);
}

::std::vector< ::std::string>
Ehr::Document::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__Document_ids[0], &__Ehr__Document_ids[2]);
}

const ::std::string&
Ehr::Document::ice_id(const ::Ice::Current&) const
{
    return __Ehr__Document_ids[0];
}

const ::std::string&
Ehr::Document::ice_staticId()
{
    return __Ehr__Document_ids[0];
}

void
Ehr::Document::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    ::Ehr::__write(__os, type);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
Ehr::Document::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    ::Ehr::__read(__is, type);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
Ehr::Document::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    ::Ehr::ice_writeDocumentType(__outS, type);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__outS);
#else
    ::Ice::Object::__write(__outS);
#endif
}

void
Ehr::Document::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    ::Ehr::ice_readDocumentType(__inS, type);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__inS, true);
#else
    ::Ice::Object::__read(__inS, true);
#endif
}

class __F__Ehr__Document : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::Document::ice_staticId());
        return new ::Ehr::Document;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__Document_Ptr = new __F__Ehr__Document;

const ::Ice::ObjectFactoryPtr&
Ehr::Document::ice_factory()
{
    return __F__Ehr__Document_Ptr;
}

class __F__Ehr__Document__Init
{
public:

    __F__Ehr__Document__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Document::ice_staticId(), ::Ehr::Document::ice_factory());
    }

    ~__F__Ehr__Document__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Document::ice_staticId());
    }
};

static __F__Ehr__Document__Init __F__Ehr__Document__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__Document__initializer() {} }
#endif

void 
Ehr::__patch__DocumentPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::DocumentPtr* p = static_cast< ::Ehr::DocumentPtr*>(__addr);
    assert(p);
    *p = ::Ehr::DocumentPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::Document::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::Document& l, const ::Ehr::Document& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::Document& l, const ::Ehr::Document& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::Prescription::Prescription(::Ehr::DocumentType __ice_type, const ::std::string& __ice_originatorName, const ::std::string& __ice_originatorProfession, const ::std::string& __ice_originatorAddress, const ::Ehr::Date& __ice_creationDate, const ::std::string& __ice_consumerName, const ::Ehr::Date& __ice_consumerDateOfBirth, const ::std::string& __ice_drugDescription, const ::std::string& __ice_form, ::Ice::Int __ice_dosage, const ::std::string& __ice_measuringUnit, const ::Ehr::Date& __ice_validFrom, const ::Ehr::Date& __ice_expires) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document(__ice_type)
#else
    ::Ehr::Document(__ice_type)
#endif
,
    originatorName(__ice_originatorName),
    originatorProfession(__ice_originatorProfession),
    originatorAddress(__ice_originatorAddress),
    creationDate(__ice_creationDate),
    consumerName(__ice_consumerName),
    consumerDateOfBirth(__ice_consumerDateOfBirth),
    drugDescription(__ice_drugDescription),
    form(__ice_form),
    dosage(__ice_dosage),
    measuringUnit(__ice_measuringUnit),
    validFrom(__ice_validFrom),
    expires(__ice_expires)
{
}

::Ice::ObjectPtr
Ehr::Prescription::ice_clone() const
{
    ::Ehr::PrescriptionPtr __p = new ::Ehr::Prescription(*this);
    return __p;
}

static const ::std::string __Ehr__Prescription_ids[3] =
{
    "::Ehr::Document",
    "::Ehr::Prescription",
    "::Ice::Object"
};

bool
Ehr::Prescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__Prescription_ids, __Ehr__Prescription_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::Prescription::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__Prescription_ids[0], &__Ehr__Prescription_ids[3]);
}

const ::std::string&
Ehr::Prescription::ice_id(const ::Ice::Current&) const
{
    return __Ehr__Prescription_ids[1];
}

const ::std::string&
Ehr::Prescription::ice_staticId()
{
    return __Ehr__Prescription_ids[1];
}

void
Ehr::Prescription::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(originatorName);
    __os->write(originatorProfession);
    __os->write(originatorAddress);
    creationDate.__write(__os);
    __os->write(consumerName);
    consumerDateOfBirth.__write(__os);
    __os->write(drugDescription);
    __os->write(form);
    __os->write(dosage);
    __os->write(measuringUnit);
    validFrom.__write(__os);
    expires.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document::__write(__os);
#else
    ::Ehr::Document::__write(__os);
#endif
}

void
Ehr::Prescription::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(originatorName);
    __is->read(originatorProfession);
    __is->read(originatorAddress);
    creationDate.__read(__is);
    __is->read(consumerName);
    consumerDateOfBirth.__read(__is);
    __is->read(drugDescription);
    __is->read(form);
    __is->read(dosage);
    __is->read(measuringUnit);
    validFrom.__read(__is);
    expires.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document::__read(__is, true);
#else
    ::Ehr::Document::__read(__is, true);
#endif
}

void
Ehr::Prescription::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeString(originatorName);
    __outS->writeString(originatorProfession);
    __outS->writeString(originatorAddress);
    ::Ehr::ice_writeDate(__outS, creationDate);
    __outS->writeString(consumerName);
    ::Ehr::ice_writeDate(__outS, consumerDateOfBirth);
    __outS->writeString(drugDescription);
    __outS->writeString(form);
    __outS->writeInt(dosage);
    __outS->writeString(measuringUnit);
    ::Ehr::ice_writeDate(__outS, validFrom);
    ::Ehr::ice_writeDate(__outS, expires);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document::__write(__outS);
#else
    ::Ehr::Document::__write(__outS);
#endif
}

void
Ehr::Prescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    originatorName = __inS->readString();
    originatorProfession = __inS->readString();
    originatorAddress = __inS->readString();
    ::Ehr::ice_readDate(__inS, creationDate);
    consumerName = __inS->readString();
    ::Ehr::ice_readDate(__inS, consumerDateOfBirth);
    drugDescription = __inS->readString();
    form = __inS->readString();
    dosage = __inS->readInt();
    measuringUnit = __inS->readString();
    ::Ehr::ice_readDate(__inS, validFrom);
    ::Ehr::ice_readDate(__inS, expires);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document::__read(__inS, true);
#else
    ::Ehr::Document::__read(__inS, true);
#endif
}

class __F__Ehr__Prescription : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::Prescription::ice_staticId());
        return new ::Ehr::Prescription;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__Prescription_Ptr = new __F__Ehr__Prescription;

const ::Ice::ObjectFactoryPtr&
Ehr::Prescription::ice_factory()
{
    return __F__Ehr__Prescription_Ptr;
}

class __F__Ehr__Prescription__Init
{
public:

    __F__Ehr__Prescription__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Prescription::ice_staticId(), ::Ehr::Prescription::ice_factory());
    }

    ~__F__Ehr__Prescription__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Prescription::ice_staticId());
    }
};

static __F__Ehr__Prescription__Init __F__Ehr__Prescription__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__Prescription__initializer() {} }
#endif

void 
Ehr::__patch__PrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::PrescriptionPtr* p = static_cast< ::Ehr::PrescriptionPtr*>(__addr);
    assert(p);
    *p = ::Ehr::PrescriptionPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::Prescription::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::Prescription& l, const ::Ehr::Prescription& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::ConsumedPrescription::ConsumedPrescription(::Ehr::DocumentType __ice_type, const ::std::string& __ice_originatorName, const ::std::string& __ice_originatorProfession, const ::std::string& __ice_originatorAddress, const ::Ehr::Date& __ice_creationDate, const ::std::string& __ice_consumerName, const ::Ehr::Date& __ice_consumerDateOfBirth, const ::std::string& __ice_drugDescription, const ::std::string& __ice_form, ::Ice::Int __ice_dosage, const ::std::string& __ice_measuringUnit, const ::Ehr::Date& __ice_validFrom, const ::Ehr::Date& __ice_expires, const ::std::string& __ice_dispenserName, const ::std::string& __ice_dispenserProfession, const ::std::string& __ice_dispenserAddress, const ::Ehr::Date& __ice_dispensingDate) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Document(__ice_type)
#else
    ::Ehr::Document(__ice_type)
#endif
,
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Prescription(__ice_type, __ice_originatorName, __ice_originatorProfession, __ice_originatorAddress, __ice_creationDate, __ice_consumerName, __ice_consumerDateOfBirth, __ice_drugDescription, __ice_form, __ice_dosage, __ice_measuringUnit, __ice_validFrom, __ice_expires)
#else
    ::Ehr::Prescription(__ice_type, __ice_originatorName, __ice_originatorProfession, __ice_originatorAddress, __ice_creationDate, __ice_consumerName, __ice_consumerDateOfBirth, __ice_drugDescription, __ice_form, __ice_dosage, __ice_measuringUnit, __ice_validFrom, __ice_expires)
#endif
,
    dispenserName(__ice_dispenserName),
    dispenserProfession(__ice_dispenserProfession),
    dispenserAddress(__ice_dispenserAddress),
    dispensingDate(__ice_dispensingDate)
{
}

::Ice::ObjectPtr
Ehr::ConsumedPrescription::ice_clone() const
{
    ::Ehr::ConsumedPrescriptionPtr __p = new ::Ehr::ConsumedPrescription(*this);
    return __p;
}

static const ::std::string __Ehr__ConsumedPrescription_ids[4] =
{
    "::Ehr::ConsumedPrescription",
    "::Ehr::Document",
    "::Ehr::Prescription",
    "::Ice::Object"
};

bool
Ehr::ConsumedPrescription::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__ConsumedPrescription_ids, __Ehr__ConsumedPrescription_ids + 4, _s);
}

::std::vector< ::std::string>
Ehr::ConsumedPrescription::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__ConsumedPrescription_ids[0], &__Ehr__ConsumedPrescription_ids[4]);
}

const ::std::string&
Ehr::ConsumedPrescription::ice_id(const ::Ice::Current&) const
{
    return __Ehr__ConsumedPrescription_ids[0];
}

const ::std::string&
Ehr::ConsumedPrescription::ice_staticId()
{
    return __Ehr__ConsumedPrescription_ids[0];
}

void
Ehr::ConsumedPrescription::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(dispenserName);
    __os->write(dispenserProfession);
    __os->write(dispenserAddress);
    dispensingDate.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Prescription::__write(__os);
#else
    ::Ehr::Prescription::__write(__os);
#endif
}

void
Ehr::ConsumedPrescription::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(dispenserName);
    __is->read(dispenserProfession);
    __is->read(dispenserAddress);
    dispensingDate.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Prescription::__read(__is, true);
#else
    ::Ehr::Prescription::__read(__is, true);
#endif
}

void
Ehr::ConsumedPrescription::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeString(dispenserName);
    __outS->writeString(dispenserProfession);
    __outS->writeString(dispenserAddress);
    ::Ehr::ice_writeDate(__outS, dispensingDate);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Prescription::__write(__outS);
#else
    ::Ehr::Prescription::__write(__outS);
#endif
}

void
Ehr::ConsumedPrescription::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    dispenserName = __inS->readString();
    dispenserProfession = __inS->readString();
    dispenserAddress = __inS->readString();
    ::Ehr::ice_readDate(__inS, dispensingDate);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Prescription::__read(__inS, true);
#else
    ::Ehr::Prescription::__read(__inS, true);
#endif
}

class __F__Ehr__ConsumedPrescription : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::ConsumedPrescription::ice_staticId());
        return new ::Ehr::ConsumedPrescription;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumedPrescription_Ptr = new __F__Ehr__ConsumedPrescription;

const ::Ice::ObjectFactoryPtr&
Ehr::ConsumedPrescription::ice_factory()
{
    return __F__Ehr__ConsumedPrescription_Ptr;
}

class __F__Ehr__ConsumedPrescription__Init
{
public:

    __F__Ehr__ConsumedPrescription__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumedPrescription::ice_staticId(), ::Ehr::ConsumedPrescription::ice_factory());
    }

    ~__F__Ehr__ConsumedPrescription__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumedPrescription::ice_staticId());
    }
};

static __F__Ehr__ConsumedPrescription__Init __F__Ehr__ConsumedPrescription__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__ConsumedPrescription__initializer() {} }
#endif

void 
Ehr::__patch__ConsumedPrescriptionPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ConsumedPrescriptionPtr* p = static_cast< ::Ehr::ConsumedPrescriptionPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ConsumedPrescriptionPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::ConsumedPrescription::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::ConsumedPrescription& l, const ::Ehr::ConsumedPrescription& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::Request::Request(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when) :
    requestor(__ice_requestor),
    when(__ice_when)
{
}

::Ice::ObjectPtr
Ehr::Request::ice_clone() const
{
    ::Ehr::RequestPtr __p = new ::Ehr::Request(*this);
    return __p;
}

static const ::std::string __Ehr__Request_ids[2] =
{
    "::Ehr::Request",
    "::Ice::Object"
};

bool
Ehr::Request::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__Request_ids, __Ehr__Request_ids + 2, _s);
}

::std::vector< ::std::string>
Ehr::Request::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__Request_ids[0], &__Ehr__Request_ids[2]);
}

const ::std::string&
Ehr::Request::ice_id(const ::Ice::Current&) const
{
    return __Ehr__Request_ids[0];
}

const ::std::string&
Ehr::Request::ice_staticId()
{
    return __Ehr__Request_ids[0];
}

void
Ehr::Request::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    requestor.__write(__os);
    when.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
Ehr::Request::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    requestor.__read(__is);
    when.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
Ehr::Request::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    ::Ehr::ice_writeAccountIdentifier(__outS, requestor);
    ::Ehr::ice_writeTimestamp(__outS, when);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__outS);
#else
    ::Ice::Object::__write(__outS);
#endif
}

void
Ehr::Request::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    ::Ehr::ice_readAccountIdentifier(__inS, requestor);
    ::Ehr::ice_readTimestamp(__inS, when);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__inS, true);
#else
    ::Ice::Object::__read(__inS, true);
#endif
}

class __F__Ehr__Request : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::Request::ice_staticId());
        return new ::Ehr::Request;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__Request_Ptr = new __F__Ehr__Request;

const ::Ice::ObjectFactoryPtr&
Ehr::Request::ice_factory()
{
    return __F__Ehr__Request_Ptr;
}

class __F__Ehr__Request__Init
{
public:

    __F__Ehr__Request__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::Request::ice_staticId(), ::Ehr::Request::ice_factory());
    }

    ~__F__Ehr__Request__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::Request::ice_staticId());
    }
};

static __F__Ehr__Request__Init __F__Ehr__Request__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__Request__initializer() {} }
#endif

void 
Ehr::__patch__RequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::RequestPtr* p = static_cast< ::Ehr::RequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::RequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::Request::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::Request& l, const ::Ehr::Request& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::Request& l, const ::Ehr::Request& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::ThirdPartyRequest::ThirdPartyRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
    owner(__ice_owner)
{
}

::Ice::ObjectPtr
Ehr::ThirdPartyRequest::ice_clone() const
{
    ::Ehr::ThirdPartyRequestPtr __p = new ::Ehr::ThirdPartyRequest(*this);
    return __p;
}

static const ::std::string __Ehr__ThirdPartyRequest_ids[3] =
{
    "::Ehr::Request",
    "::Ehr::ThirdPartyRequest",
    "::Ice::Object"
};

bool
Ehr::ThirdPartyRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__ThirdPartyRequest_ids, __Ehr__ThirdPartyRequest_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::ThirdPartyRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__ThirdPartyRequest_ids[0], &__Ehr__ThirdPartyRequest_ids[3]);
}

const ::std::string&
Ehr::ThirdPartyRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__ThirdPartyRequest_ids[1];
}

const ::std::string&
Ehr::ThirdPartyRequest::ice_staticId()
{
    return __Ehr__ThirdPartyRequest_ids[1];
}

void
Ehr::ThirdPartyRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    owner.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__os);
#else
    ::Ehr::Request::__write(__os);
#endif
}

void
Ehr::ThirdPartyRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    owner.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__is, true);
#else
    ::Ehr::Request::__read(__is, true);
#endif
}

void
Ehr::ThirdPartyRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    ::Ehr::ice_writeAccountIdentifier(__outS, owner);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__outS);
#else
    ::Ehr::Request::__write(__outS);
#endif
}

void
Ehr::ThirdPartyRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    ::Ehr::ice_readAccountIdentifier(__inS, owner);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__inS, true);
#else
    ::Ehr::Request::__read(__inS, true);
#endif
}

class __F__Ehr__ThirdPartyRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::ThirdPartyRequest::ice_staticId());
        return new ::Ehr::ThirdPartyRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__ThirdPartyRequest_Ptr = new __F__Ehr__ThirdPartyRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::ThirdPartyRequest::ice_factory()
{
    return __F__Ehr__ThirdPartyRequest_Ptr;
}

class __F__Ehr__ThirdPartyRequest__Init
{
public:

    __F__Ehr__ThirdPartyRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId(), ::Ehr::ThirdPartyRequest::ice_factory());
    }

    ~__F__Ehr__ThirdPartyRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ThirdPartyRequest::ice_staticId());
    }
};

static __F__Ehr__ThirdPartyRequest__Init __F__Ehr__ThirdPartyRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__ThirdPartyRequest__initializer() {} }
#endif

void 
Ehr::__patch__ThirdPartyRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ThirdPartyRequestPtr* p = static_cast< ::Ehr::ThirdPartyRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ThirdPartyRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::ThirdPartyRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::ThirdPartyRequest& l, const ::Ehr::ThirdPartyRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::CreatePrescriptionRequest::CreatePrescriptionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, const ::Ehr::EncryptedDocument& __ice_prescription) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#else
    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#endif
,
    prescription(__ice_prescription)
{
}

::Ice::ObjectPtr
Ehr::CreatePrescriptionRequest::ice_clone() const
{
    ::Ehr::CreatePrescriptionRequestPtr __p = new ::Ehr::CreatePrescriptionRequest(*this);
    return __p;
}

static const ::std::string __Ehr__CreatePrescriptionRequest_ids[4] =
{
    "::Ehr::CreatePrescriptionRequest",
    "::Ehr::Request",
    "::Ehr::ThirdPartyRequest",
    "::Ice::Object"
};

bool
Ehr::CreatePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__CreatePrescriptionRequest_ids, __Ehr__CreatePrescriptionRequest_ids + 4, _s);
}

::std::vector< ::std::string>
Ehr::CreatePrescriptionRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__CreatePrescriptionRequest_ids[0], &__Ehr__CreatePrescriptionRequest_ids[4]);
}

const ::std::string&
Ehr::CreatePrescriptionRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__CreatePrescriptionRequest_ids[0];
}

const ::std::string&
Ehr::CreatePrescriptionRequest::ice_staticId()
{
    return __Ehr__CreatePrescriptionRequest_ids[0];
}

void
Ehr::CreatePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    prescription.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__os);
#else
    ::Ehr::ThirdPartyRequest::__write(__os);
#endif
}

void
Ehr::CreatePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    prescription.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__is, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__is, true);
#endif
}

void
Ehr::CreatePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    ::Ehr::ice_writeEncryptedDocument(__outS, prescription);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__outS);
#else
    ::Ehr::ThirdPartyRequest::__write(__outS);
#endif
}

void
Ehr::CreatePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    ::Ehr::ice_readEncryptedDocument(__inS, prescription);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__inS, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__inS, true);
#endif
}

class __F__Ehr__CreatePrescriptionRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::CreatePrescriptionRequest::ice_staticId());
        return new ::Ehr::CreatePrescriptionRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePrescriptionRequest_Ptr = new __F__Ehr__CreatePrescriptionRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::CreatePrescriptionRequest::ice_factory()
{
    return __F__Ehr__CreatePrescriptionRequest_Ptr;
}

class __F__Ehr__CreatePrescriptionRequest__Init
{
public:

    __F__Ehr__CreatePrescriptionRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId(), ::Ehr::CreatePrescriptionRequest::ice_factory());
    }

    ~__F__Ehr__CreatePrescriptionRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePrescriptionRequest::ice_staticId());
    }
};

static __F__Ehr__CreatePrescriptionRequest__Init __F__Ehr__CreatePrescriptionRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__CreatePrescriptionRequest__initializer() {} }
#endif

void 
Ehr::__patch__CreatePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::CreatePrescriptionRequestPtr* p = static_cast< ::Ehr::CreatePrescriptionRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::CreatePrescriptionRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::CreatePrescriptionRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::CreatePrescriptionRequest& l, const ::Ehr::CreatePrescriptionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::ConsumePrescriptionRequest::ConsumePrescriptionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, ::Ice::Long __ice_prescriptionId, const ::Ehr::EncryptedDocument& __ice_consumedPrescription) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#else
    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#endif
,
    prescriptionId(__ice_prescriptionId),
    consumedPrescription(__ice_consumedPrescription)
{
}

::Ice::ObjectPtr
Ehr::ConsumePrescriptionRequest::ice_clone() const
{
    ::Ehr::ConsumePrescriptionRequestPtr __p = new ::Ehr::ConsumePrescriptionRequest(*this);
    return __p;
}

static const ::std::string __Ehr__ConsumePrescriptionRequest_ids[4] =
{
    "::Ehr::ConsumePrescriptionRequest",
    "::Ehr::Request",
    "::Ehr::ThirdPartyRequest",
    "::Ice::Object"
};

bool
Ehr::ConsumePrescriptionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__ConsumePrescriptionRequest_ids, __Ehr__ConsumePrescriptionRequest_ids + 4, _s);
}

::std::vector< ::std::string>
Ehr::ConsumePrescriptionRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__ConsumePrescriptionRequest_ids[0], &__Ehr__ConsumePrescriptionRequest_ids[4]);
}

const ::std::string&
Ehr::ConsumePrescriptionRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__ConsumePrescriptionRequest_ids[0];
}

const ::std::string&
Ehr::ConsumePrescriptionRequest::ice_staticId()
{
    return __Ehr__ConsumePrescriptionRequest_ids[0];
}

void
Ehr::ConsumePrescriptionRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(prescriptionId);
    consumedPrescription.__write(__os);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__os);
#else
    ::Ehr::ThirdPartyRequest::__write(__os);
#endif
}

void
Ehr::ConsumePrescriptionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(prescriptionId);
    consumedPrescription.__read(__is);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__is, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__is, true);
#endif
}

void
Ehr::ConsumePrescriptionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeLong(prescriptionId);
    ::Ehr::ice_writeEncryptedDocument(__outS, consumedPrescription);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__outS);
#else
    ::Ehr::ThirdPartyRequest::__write(__outS);
#endif
}

void
Ehr::ConsumePrescriptionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    prescriptionId = __inS->readLong();
    ::Ehr::ice_readEncryptedDocument(__inS, consumedPrescription);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__inS, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__inS, true);
#endif
}

class __F__Ehr__ConsumePrescriptionRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::ConsumePrescriptionRequest::ice_staticId());
        return new ::Ehr::ConsumePrescriptionRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__ConsumePrescriptionRequest_Ptr = new __F__Ehr__ConsumePrescriptionRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::ConsumePrescriptionRequest::ice_factory()
{
    return __F__Ehr__ConsumePrescriptionRequest_Ptr;
}

class __F__Ehr__ConsumePrescriptionRequest__Init
{
public:

    __F__Ehr__ConsumePrescriptionRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId(), ::Ehr::ConsumePrescriptionRequest::ice_factory());
    }

    ~__F__Ehr__ConsumePrescriptionRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ConsumePrescriptionRequest::ice_staticId());
    }
};

static __F__Ehr__ConsumePrescriptionRequest__Init __F__Ehr__ConsumePrescriptionRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__ConsumePrescriptionRequest__initializer() {} }
#endif

void 
Ehr::__patch__ConsumePrescriptionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ConsumePrescriptionRequestPtr* p = static_cast< ::Ehr::ConsumePrescriptionRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ConsumePrescriptionRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::ConsumePrescriptionRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::ConsumePrescriptionRequest& l, const ::Ehr::ConsumePrescriptionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::ListDocumentsRequest::ListDocumentsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#else
    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#endif

{
}

::Ice::ObjectPtr
Ehr::ListDocumentsRequest::ice_clone() const
{
    ::Ehr::ListDocumentsRequestPtr __p = new ::Ehr::ListDocumentsRequest(*this);
    return __p;
}

static const ::std::string __Ehr__ListDocumentsRequest_ids[4] =
{
    "::Ehr::ListDocumentsRequest",
    "::Ehr::Request",
    "::Ehr::ThirdPartyRequest",
    "::Ice::Object"
};

bool
Ehr::ListDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__ListDocumentsRequest_ids, __Ehr__ListDocumentsRequest_ids + 4, _s);
}

::std::vector< ::std::string>
Ehr::ListDocumentsRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__ListDocumentsRequest_ids[0], &__Ehr__ListDocumentsRequest_ids[4]);
}

const ::std::string&
Ehr::ListDocumentsRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__ListDocumentsRequest_ids[0];
}

const ::std::string&
Ehr::ListDocumentsRequest::ice_staticId()
{
    return __Ehr__ListDocumentsRequest_ids[0];
}

void
Ehr::ListDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__os);
#else
    ::Ehr::ThirdPartyRequest::__write(__os);
#endif
}

void
Ehr::ListDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__is, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__is, true);
#endif
}

void
Ehr::ListDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__outS);
#else
    ::Ehr::ThirdPartyRequest::__write(__outS);
#endif
}

void
Ehr::ListDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__inS, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__inS, true);
#endif
}

class __F__Ehr__ListDocumentsRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::ListDocumentsRequest::ice_staticId());
        return new ::Ehr::ListDocumentsRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__ListDocumentsRequest_Ptr = new __F__Ehr__ListDocumentsRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::ListDocumentsRequest::ice_factory()
{
    return __F__Ehr__ListDocumentsRequest_Ptr;
}

class __F__Ehr__ListDocumentsRequest__Init
{
public:

    __F__Ehr__ListDocumentsRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId(), ::Ehr::ListDocumentsRequest::ice_factory());
    }

    ~__F__Ehr__ListDocumentsRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListDocumentsRequest::ice_staticId());
    }
};

static __F__Ehr__ListDocumentsRequest__Init __F__Ehr__ListDocumentsRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__ListDocumentsRequest__initializer() {} }
#endif

void 
Ehr::__patch__ListDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ListDocumentsRequestPtr* p = static_cast< ::Ehr::ListDocumentsRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ListDocumentsRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::ListDocumentsRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::ListDocumentsRequest& l, const ::Ehr::ListDocumentsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::FindDocumentsRequest::FindDocumentsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, const ::Ehr::AccountIdentifier& __ice_owner, bool __ice_hasFrom, const ::Ehr::Timestamp& __ice_from, bool __ice_hasTill, const ::Ehr::Timestamp& __ice_till, ::Ehr::DocumentType __ice_type, ::Ice::Long __ice_documentId) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#else
    ::Ehr::ThirdPartyRequest(__ice_requestor, __ice_when, __ice_owner)
#endif
,
    hasFrom(__ice_hasFrom),
    from(__ice_from),
    hasTill(__ice_hasTill),
    till(__ice_till),
    type(__ice_type),
    documentId(__ice_documentId)
{
}

::Ice::ObjectPtr
Ehr::FindDocumentsRequest::ice_clone() const
{
    ::Ehr::FindDocumentsRequestPtr __p = new ::Ehr::FindDocumentsRequest(*this);
    return __p;
}

static const ::std::string __Ehr__FindDocumentsRequest_ids[4] =
{
    "::Ehr::FindDocumentsRequest",
    "::Ehr::Request",
    "::Ehr::ThirdPartyRequest",
    "::Ice::Object"
};

bool
Ehr::FindDocumentsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__FindDocumentsRequest_ids, __Ehr__FindDocumentsRequest_ids + 4, _s);
}

::std::vector< ::std::string>
Ehr::FindDocumentsRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__FindDocumentsRequest_ids[0], &__Ehr__FindDocumentsRequest_ids[4]);
}

const ::std::string&
Ehr::FindDocumentsRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__FindDocumentsRequest_ids[0];
}

const ::std::string&
Ehr::FindDocumentsRequest::ice_staticId()
{
    return __Ehr__FindDocumentsRequest_ids[0];
}

void
Ehr::FindDocumentsRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(hasFrom);
    from.__write(__os);
    __os->write(hasTill);
    till.__write(__os);
    ::Ehr::__write(__os, type);
    __os->write(documentId);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__os);
#else
    ::Ehr::ThirdPartyRequest::__write(__os);
#endif
}

void
Ehr::FindDocumentsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(hasFrom);
    from.__read(__is);
    __is->read(hasTill);
    till.__read(__is);
    ::Ehr::__read(__is, type);
    __is->read(documentId);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__is, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__is, true);
#endif
}

void
Ehr::FindDocumentsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeBool(hasFrom);
    ::Ehr::ice_writeTimestamp(__outS, from);
    __outS->writeBool(hasTill);
    ::Ehr::ice_writeTimestamp(__outS, till);
    ::Ehr::ice_writeDocumentType(__outS, type);
    __outS->writeLong(documentId);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__write(__outS);
#else
    ::Ehr::ThirdPartyRequest::__write(__outS);
#endif
}

void
Ehr::FindDocumentsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    hasFrom = __inS->readBool();
    ::Ehr::ice_readTimestamp(__inS, from);
    hasTill = __inS->readBool();
    ::Ehr::ice_readTimestamp(__inS, till);
    ::Ehr::ice_readDocumentType(__inS, type);
    documentId = __inS->readLong();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    ThirdPartyRequest::__read(__inS, true);
#else
    ::Ehr::ThirdPartyRequest::__read(__inS, true);
#endif
}

class __F__Ehr__FindDocumentsRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::FindDocumentsRequest::ice_staticId());
        return new ::Ehr::FindDocumentsRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__FindDocumentsRequest_Ptr = new __F__Ehr__FindDocumentsRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::FindDocumentsRequest::ice_factory()
{
    return __F__Ehr__FindDocumentsRequest_Ptr;
}

class __F__Ehr__FindDocumentsRequest__Init
{
public:

    __F__Ehr__FindDocumentsRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId(), ::Ehr::FindDocumentsRequest::ice_factory());
    }

    ~__F__Ehr__FindDocumentsRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::FindDocumentsRequest::ice_staticId());
    }
};

static __F__Ehr__FindDocumentsRequest__Init __F__Ehr__FindDocumentsRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__FindDocumentsRequest__initializer() {} }
#endif

void 
Ehr::__patch__FindDocumentsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::FindDocumentsRequestPtr* p = static_cast< ::Ehr::FindDocumentsRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::FindDocumentsRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::FindDocumentsRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::FindDocumentsRequest& l, const ::Ehr::FindDocumentsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::CreatePermissionRequest::CreatePermissionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, const ::Ehr::AccountIdentifier& __ice_account, ::Ehr::AccessType __ice_access) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
    documentId(__ice_documentId),
    account(__ice_account),
    access(__ice_access)
{
}

::Ice::ObjectPtr
Ehr::CreatePermissionRequest::ice_clone() const
{
    ::Ehr::CreatePermissionRequestPtr __p = new ::Ehr::CreatePermissionRequest(*this);
    return __p;
}

static const ::std::string __Ehr__CreatePermissionRequest_ids[3] =
{
    "::Ehr::CreatePermissionRequest",
    "::Ehr::Request",
    "::Ice::Object"
};

bool
Ehr::CreatePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__CreatePermissionRequest_ids, __Ehr__CreatePermissionRequest_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::CreatePermissionRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__CreatePermissionRequest_ids[0], &__Ehr__CreatePermissionRequest_ids[3]);
}

const ::std::string&
Ehr::CreatePermissionRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__CreatePermissionRequest_ids[0];
}

const ::std::string&
Ehr::CreatePermissionRequest::ice_staticId()
{
    return __Ehr__CreatePermissionRequest_ids[0];
}

void
Ehr::CreatePermissionRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(documentId);
    account.__write(__os);
    ::Ehr::__write(__os, access);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__os);
#else
    ::Ehr::Request::__write(__os);
#endif
}

void
Ehr::CreatePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(documentId);
    account.__read(__is);
    ::Ehr::__read(__is, access);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__is, true);
#else
    ::Ehr::Request::__read(__is, true);
#endif
}

void
Ehr::CreatePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeLong(documentId);
    ::Ehr::ice_writeAccountIdentifier(__outS, account);
    ::Ehr::ice_writeAccessType(__outS, access);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__outS);
#else
    ::Ehr::Request::__write(__outS);
#endif
}

void
Ehr::CreatePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    documentId = __inS->readLong();
    ::Ehr::ice_readAccountIdentifier(__inS, account);
    ::Ehr::ice_readAccessType(__inS, access);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__inS, true);
#else
    ::Ehr::Request::__read(__inS, true);
#endif
}

class __F__Ehr__CreatePermissionRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::CreatePermissionRequest::ice_staticId());
        return new ::Ehr::CreatePermissionRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__CreatePermissionRequest_Ptr = new __F__Ehr__CreatePermissionRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::CreatePermissionRequest::ice_factory()
{
    return __F__Ehr__CreatePermissionRequest_Ptr;
}

class __F__Ehr__CreatePermissionRequest__Init
{
public:

    __F__Ehr__CreatePermissionRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId(), ::Ehr::CreatePermissionRequest::ice_factory());
    }

    ~__F__Ehr__CreatePermissionRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::CreatePermissionRequest::ice_staticId());
    }
};

static __F__Ehr__CreatePermissionRequest__Init __F__Ehr__CreatePermissionRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__CreatePermissionRequest__initializer() {} }
#endif

void 
Ehr::__patch__CreatePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::CreatePermissionRequestPtr* p = static_cast< ::Ehr::CreatePermissionRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::CreatePermissionRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::CreatePermissionRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::CreatePermissionRequest& l, const ::Ehr::CreatePermissionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::SetDefaultAccessRequest::SetDefaultAccessRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ehr::AccessType __ice_access) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
    documentId(__ice_documentId),
    access(__ice_access)
{
}

::Ice::ObjectPtr
Ehr::SetDefaultAccessRequest::ice_clone() const
{
    ::Ehr::SetDefaultAccessRequestPtr __p = new ::Ehr::SetDefaultAccessRequest(*this);
    return __p;
}

static const ::std::string __Ehr__SetDefaultAccessRequest_ids[3] =
{
    "::Ehr::Request",
    "::Ehr::SetDefaultAccessRequest",
    "::Ice::Object"
};

bool
Ehr::SetDefaultAccessRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__SetDefaultAccessRequest_ids, __Ehr__SetDefaultAccessRequest_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::SetDefaultAccessRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__SetDefaultAccessRequest_ids[0], &__Ehr__SetDefaultAccessRequest_ids[3]);
}

const ::std::string&
Ehr::SetDefaultAccessRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__SetDefaultAccessRequest_ids[1];
}

const ::std::string&
Ehr::SetDefaultAccessRequest::ice_staticId()
{
    return __Ehr__SetDefaultAccessRequest_ids[1];
}

void
Ehr::SetDefaultAccessRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(documentId);
    ::Ehr::__write(__os, access);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__os);
#else
    ::Ehr::Request::__write(__os);
#endif
}

void
Ehr::SetDefaultAccessRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(documentId);
    ::Ehr::__read(__is, access);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__is, true);
#else
    ::Ehr::Request::__read(__is, true);
#endif
}

void
Ehr::SetDefaultAccessRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeLong(documentId);
    ::Ehr::ice_writeAccessType(__outS, access);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__outS);
#else
    ::Ehr::Request::__write(__outS);
#endif
}

void
Ehr::SetDefaultAccessRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    documentId = __inS->readLong();
    ::Ehr::ice_readAccessType(__inS, access);
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__inS, true);
#else
    ::Ehr::Request::__read(__inS, true);
#endif
}

class __F__Ehr__SetDefaultAccessRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::SetDefaultAccessRequest::ice_staticId());
        return new ::Ehr::SetDefaultAccessRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__SetDefaultAccessRequest_Ptr = new __F__Ehr__SetDefaultAccessRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::SetDefaultAccessRequest::ice_factory()
{
    return __F__Ehr__SetDefaultAccessRequest_Ptr;
}

class __F__Ehr__SetDefaultAccessRequest__Init
{
public:

    __F__Ehr__SetDefaultAccessRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId(), ::Ehr::SetDefaultAccessRequest::ice_factory());
    }

    ~__F__Ehr__SetDefaultAccessRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::SetDefaultAccessRequest::ice_staticId());
    }
};

static __F__Ehr__SetDefaultAccessRequest__Init __F__Ehr__SetDefaultAccessRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__SetDefaultAccessRequest__initializer() {} }
#endif

void 
Ehr::__patch__SetDefaultAccessRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::SetDefaultAccessRequestPtr* p = static_cast< ::Ehr::SetDefaultAccessRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::SetDefaultAccessRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::SetDefaultAccessRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::SetDefaultAccessRequest& l, const ::Ehr::SetDefaultAccessRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::ListPermissionsRequest::ListPermissionsRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
    documentId(__ice_documentId)
{
}

::Ice::ObjectPtr
Ehr::ListPermissionsRequest::ice_clone() const
{
    ::Ehr::ListPermissionsRequestPtr __p = new ::Ehr::ListPermissionsRequest(*this);
    return __p;
}

static const ::std::string __Ehr__ListPermissionsRequest_ids[3] =
{
    "::Ehr::ListPermissionsRequest",
    "::Ehr::Request",
    "::Ice::Object"
};

bool
Ehr::ListPermissionsRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__ListPermissionsRequest_ids, __Ehr__ListPermissionsRequest_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::ListPermissionsRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__ListPermissionsRequest_ids[0], &__Ehr__ListPermissionsRequest_ids[3]);
}

const ::std::string&
Ehr::ListPermissionsRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__ListPermissionsRequest_ids[0];
}

const ::std::string&
Ehr::ListPermissionsRequest::ice_staticId()
{
    return __Ehr__ListPermissionsRequest_ids[0];
}

void
Ehr::ListPermissionsRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(documentId);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__os);
#else
    ::Ehr::Request::__write(__os);
#endif
}

void
Ehr::ListPermissionsRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(documentId);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__is, true);
#else
    ::Ehr::Request::__read(__is, true);
#endif
}

void
Ehr::ListPermissionsRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeLong(documentId);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__outS);
#else
    ::Ehr::Request::__write(__outS);
#endif
}

void
Ehr::ListPermissionsRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    documentId = __inS->readLong();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__inS, true);
#else
    ::Ehr::Request::__read(__inS, true);
#endif
}

class __F__Ehr__ListPermissionsRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::ListPermissionsRequest::ice_staticId());
        return new ::Ehr::ListPermissionsRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__ListPermissionsRequest_Ptr = new __F__Ehr__ListPermissionsRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::ListPermissionsRequest::ice_factory()
{
    return __F__Ehr__ListPermissionsRequest_Ptr;
}

class __F__Ehr__ListPermissionsRequest__Init
{
public:

    __F__Ehr__ListPermissionsRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId(), ::Ehr::ListPermissionsRequest::ice_factory());
    }

    ~__F__Ehr__ListPermissionsRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::ListPermissionsRequest::ice_staticId());
    }
};

static __F__Ehr__ListPermissionsRequest__Init __F__Ehr__ListPermissionsRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__ListPermissionsRequest__initializer() {} }
#endif

void 
Ehr::__patch__ListPermissionsRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ListPermissionsRequestPtr* p = static_cast< ::Ehr::ListPermissionsRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ListPermissionsRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::ListPermissionsRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::ListPermissionsRequest& l, const ::Ehr::ListPermissionsRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

Ehr::RemovePermissionRequest::RemovePermissionRequest(const ::Ehr::AccountIdentifier& __ice_requestor, const ::Ehr::Timestamp& __ice_when, ::Ice::Long __ice_documentId, ::Ice::Long __ice_permissionId) :
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request(__ice_requestor, __ice_when)
#else
    ::Ehr::Request(__ice_requestor, __ice_when)
#endif
,
    documentId(__ice_documentId),
    permissionId(__ice_permissionId)
{
}

::Ice::ObjectPtr
Ehr::RemovePermissionRequest::ice_clone() const
{
    ::Ehr::RemovePermissionRequestPtr __p = new ::Ehr::RemovePermissionRequest(*this);
    return __p;
}

static const ::std::string __Ehr__RemovePermissionRequest_ids[3] =
{
    "::Ehr::RemovePermissionRequest",
    "::Ehr::Request",
    "::Ice::Object"
};

bool
Ehr::RemovePermissionRequest::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__RemovePermissionRequest_ids, __Ehr__RemovePermissionRequest_ids + 3, _s);
}

::std::vector< ::std::string>
Ehr::RemovePermissionRequest::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__RemovePermissionRequest_ids[0], &__Ehr__RemovePermissionRequest_ids[3]);
}

const ::std::string&
Ehr::RemovePermissionRequest::ice_id(const ::Ice::Current&) const
{
    return __Ehr__RemovePermissionRequest_ids[0];
}

const ::std::string&
Ehr::RemovePermissionRequest::ice_staticId()
{
    return __Ehr__RemovePermissionRequest_ids[0];
}

void
Ehr::RemovePermissionRequest::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->write(documentId);
    __os->write(permissionId);
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__os);
#else
    ::Ehr::Request::__write(__os);
#endif
}

void
Ehr::RemovePermissionRequest::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->read(documentId);
    __is->read(permissionId);
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__is, true);
#else
    ::Ehr::Request::__read(__is, true);
#endif
}

void
Ehr::RemovePermissionRequest::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->writeLong(documentId);
    __outS->writeLong(permissionId);
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__write(__outS);
#else
    ::Ehr::Request::__write(__outS);
#endif
}

void
Ehr::RemovePermissionRequest::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    documentId = __inS->readLong();
    permissionId = __inS->readLong();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Request::__read(__inS, true);
#else
    ::Ehr::Request::__read(__inS, true);
#endif
}

class __F__Ehr__RemovePermissionRequest : public ::Ice::ObjectFactory
{
public:

    virtual ::Ice::ObjectPtr
    create(const ::std::string& type)
    {
        assert(type == ::Ehr::RemovePermissionRequest::ice_staticId());
        return new ::Ehr::RemovePermissionRequest;
    }

    virtual void
    destroy()
    {
    }
};

static ::Ice::ObjectFactoryPtr __F__Ehr__RemovePermissionRequest_Ptr = new __F__Ehr__RemovePermissionRequest;

const ::Ice::ObjectFactoryPtr&
Ehr::RemovePermissionRequest::ice_factory()
{
    return __F__Ehr__RemovePermissionRequest_Ptr;
}

class __F__Ehr__RemovePermissionRequest__Init
{
public:

    __F__Ehr__RemovePermissionRequest__Init()
    {
        ::IceInternal::factoryTable->addObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId(), ::Ehr::RemovePermissionRequest::ice_factory());
    }

    ~__F__Ehr__RemovePermissionRequest__Init()
    {
        ::IceInternal::factoryTable->removeObjectFactory(::Ehr::RemovePermissionRequest::ice_staticId());
    }
};

static __F__Ehr__RemovePermissionRequest__Init __F__Ehr__RemovePermissionRequest__i;

#ifdef __APPLE__
extern "C" { void __F__Ehr__RemovePermissionRequest__initializer() {} }
#endif

void 
Ehr::__patch__RemovePermissionRequestPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::RemovePermissionRequestPtr* p = static_cast< ::Ehr::RemovePermissionRequestPtr*>(__addr);
    assert(p);
    *p = ::Ehr::RemovePermissionRequestPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::RemovePermissionRequest::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::RemovePermissionRequest& l, const ::Ehr::RemovePermissionRequest& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

::Ice::ObjectPtr
Ehr::Provider::ice_clone() const
{
    throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
    return 0; // to avoid a warning with some compilers
}

static const ::std::string __Ehr__Provider_ids[2] =
{
    "::Ehr::Provider",
    "::Ice::Object"
};

bool
Ehr::Provider::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Ehr__Provider_ids, __Ehr__Provider_ids + 2, _s);
}

::std::vector< ::std::string>
Ehr::Provider::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Ehr__Provider_ids[0], &__Ehr__Provider_ids[2]);
}

const ::std::string&
Ehr::Provider::ice_id(const ::Ice::Current&) const
{
    return __Ehr__Provider_ids[0];
}

const ::std::string&
Ehr::Provider::ice_staticId()
{
    return __Ehr__Provider_ids[0];
}

::Ice::DispatchStatus
Ehr::Provider::___createPrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::CreatePrescriptionRequestPtr request;
    ::Ehr::Signature requestorSignature;
    ::Ehr::Signature ownerSignature;
    __is->read(::Ehr::__patch__CreatePrescriptionRequestPtr, &request);
    requestorSignature.__read(__is);
    ownerSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        createPrescription(request, requestorSignature, ownerSignature, __current);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___consumePrescription(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::ConsumePrescriptionRequestPtr request;
    ::Ehr::Signature requestorSignature;
    ::Ehr::Signature ownerSignature;
    __is->read(::Ehr::__patch__ConsumePrescriptionRequestPtr, &request);
    requestorSignature.__read(__is);
    ownerSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        consumePrescription(request, requestorSignature, ownerSignature, __current);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___listDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::ListDocumentsRequestPtr request;
    ::Ehr::Signature requestorSignature;
    ::Ehr::Signature ownerSignature;
    __is->read(::Ehr::__patch__ListDocumentsRequestPtr, &request);
    requestorSignature.__read(__is);
    ownerSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::Ehr::DocumentList __ret = listDocuments(request, requestorSignature, ownerSignature, __current);
        if(__ret.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
        }
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___findDocuments(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::FindDocumentsRequestPtr request;
    ::Ehr::Signature requestorSignature;
    ::Ehr::Signature ownerSignature;
    __is->read(::Ehr::__patch__FindDocumentsRequestPtr, &request);
    requestorSignature.__read(__is);
    ownerSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::Ehr::DocumentList __ret = findDocuments(request, requestorSignature, ownerSignature, __current);
        if(__ret.size() == 0)
        {
            __os->writeSize(0);
        }
        else
        {
            ::Ehr::__writeDocumentList(__os, &__ret[0], &__ret[0] + __ret.size());
        }
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___setDefaultAccess(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::SetDefaultAccessRequestPtr request;
    ::Ehr::Signature requestorSignature;
    __is->read(::Ehr::__patch__SetDefaultAccessRequestPtr, &request);
    requestorSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        setDefaultAccess(request, requestorSignature, __current);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___createPermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::CreatePermissionRequestPtr request;
    ::Ehr::Signature requestorSignature;
    __is->read(::Ehr::__patch__CreatePermissionRequestPtr, &request);
    requestorSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        createPermission(request, requestorSignature, __current);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___listPermissions(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::ListPermissionsRequestPtr request;
    ::Ehr::Signature requestorSignature;
    __is->read(::Ehr::__patch__ListPermissionsRequestPtr, &request);
    requestorSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        ::Ehr::Permissions __ret = listPermissions(request, requestorSignature, __current);
        __ret.__write(__os);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Ehr::Provider::___removePermission(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.is();
    __is->startReadEncaps();
    ::Ehr::RemovePermissionRequestPtr request;
    ::Ehr::Signature requestorSignature;
    __is->read(::Ehr::__patch__RemovePermissionRequestPtr, &request);
    requestorSignature.__read(__is);
    __is->readPendingObjects();
    __is->endReadEncaps();
    ::IceInternal::BasicStream* __os = __inS.os();
    try
    {
        removePermission(request, requestorSignature, __current);
    }
    catch(const ::Ehr::EhrException& __ex)
    {
        __os->write(__ex);
        return ::Ice::DispatchUserException;
    }
    return ::Ice::DispatchOK;
}

static ::std::string __Ehr__Provider_all[] =
{
    "consumePrescription",
    "createPermission",
    "createPrescription",
    "findDocuments",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping",
    "listDocuments",
    "listPermissions",
    "removePermission",
    "setDefaultAccess"
};

::Ice::DispatchStatus
Ehr::Provider::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Ehr__Provider_all, __Ehr__Provider_all + 12, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Ehr__Provider_all)
    {
        case 0:
        {
            return ___consumePrescription(in, current);
        }
        case 1:
        {
            return ___createPermission(in, current);
        }
        case 2:
        {
            return ___createPrescription(in, current);
        }
        case 3:
        {
            return ___findDocuments(in, current);
        }
        case 4:
        {
            return ___ice_id(in, current);
        }
        case 5:
        {
            return ___ice_ids(in, current);
        }
        case 6:
        {
            return ___ice_isA(in, current);
        }
        case 7:
        {
            return ___ice_ping(in, current);
        }
        case 8:
        {
            return ___listDocuments(in, current);
        }
        case 9:
        {
            return ___listPermissions(in, current);
        }
        case 10:
        {
            return ___removePermission(in, current);
        }
        case 11:
        {
            return ___setDefaultAccess(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Ehr::Provider::__write(::IceInternal::BasicStream* __os) const
{
    __os->writeTypeId(ice_staticId());
    __os->startWriteSlice();
    __os->endWriteSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__os);
#else
    ::Ice::Object::__write(__os);
#endif
}

void
Ehr::Provider::__read(::IceInternal::BasicStream* __is, bool __rid)
{
    if(__rid)
    {
        ::std::string myId;
        __is->readTypeId(myId);
    }
    __is->startReadSlice();
    __is->endReadSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__is, true);
#else
    ::Ice::Object::__read(__is, true);
#endif
}

void
Ehr::Provider::__write(const ::Ice::OutputStreamPtr& __outS) const
{
    __outS->writeTypeId(ice_staticId());
    __outS->startSlice();
    __outS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__write(__outS);
#else
    ::Ice::Object::__write(__outS);
#endif
}

void
Ehr::Provider::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)
{
    if(__rid)
    {
        __inS->readTypeId();
    }
    __inS->startSlice();
    __inS->endSlice();
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
    Object::__read(__inS, true);
#else
    ::Ice::Object::__read(__inS, true);
#endif
}

void 
Ehr::__patch__ProviderPtr(void* __addr, ::Ice::ObjectPtr& v)
{
    ::Ehr::ProviderPtr* p = static_cast< ::Ehr::ProviderPtr*>(__addr);
    assert(p);
    *p = ::Ehr::ProviderPtr::dynamicCast(v);
    if(v && !*p)
    {
        IceInternal::Ex::throwUOE(::Ehr::Provider::ice_staticId(), v->ice_id());
    }
}

bool
Ehr::operator==(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

bool
Ehr::operator<(const ::Ehr::Provider& l, const ::Ehr::Provider& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}