www.pudn.com > 200311301927570.rar > mqoa.tli

// Created by Microsoft (R) C/C++ Compiler Version 12.00.8168.0 (42a9ca02). 
// 
// f:\sms\ftp\new sms\source code\app2\hwcmppapi10\release\mqoa.tli 
// 
// Wrapper implementations for Win32 type library C:\WINNT\system32\mqoa.dll 
// compiler-generated file created 07/06/03 at 12:18:03 - DO NOT EDIT! 
 
#pragma once 
 
// 
// interface IMSMQQuery wrapper method implementations 
// 
 
inline IMSMQQueueInfosPtr IMSMQQuery::LookupQueue ( VARIANT * QueueGuid, VARIANT * ServiceTypeGuid, VARIANT * Label, VARIANT * CreateTime, VARIANT * ModifyTime, VARIANT * RelServiceType, VARIANT * RelLabel, VARIANT * RelCreateTime, VARIANT * RelModifyTime ) { 
    struct IMSMQQueueInfos * _result; 
    HRESULT _hr = raw_LookupQueue(QueueGuid, ServiceTypeGuid, Label, CreateTime, ModifyTime, RelServiceType, RelLabel, RelCreateTime, RelModifyTime, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfosPtr(_result, false); 
} 
 
// 
// interface IMSMQQueueInfos wrapper method implementations 
// 
 
inline HRESULT IMSMQQueueInfos::Reset ( ) { 
    HRESULT _hr = raw_Reset(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQQueueInfoPtr IMSMQQueueInfos::Next ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = raw_Next(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
// 
// interface IMSMQQueueInfo wrapper method implementations 
// 
 
inline _bstr_t IMSMQQueueInfo::GetQueueGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_QueueGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline _bstr_t IMSMQQueueInfo::GetServiceTypeGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_ServiceTypeGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo::PutServiceTypeGuid ( _bstr_t pbstrGuidServiceType ) { 
    HRESULT _hr = put_ServiceTypeGuid(pbstrGuidServiceType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo::GetLabel ( ) { 
    BSTR _result; 
    HRESULT _hr = get_Label(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo::PutLabel ( _bstr_t pbstrLabel ) { 
    HRESULT _hr = put_Label(pbstrLabel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo::GetPathName ( ) { 
    BSTR _result; 
    HRESULT _hr = get_PathName(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo::PutPathName ( _bstr_t pbstrPathName ) { 
    HRESULT _hr = put_PathName(pbstrPathName); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo::GetFormatName ( ) { 
    BSTR _result; 
    HRESULT _hr = get_FormatName(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo::PutFormatName ( _bstr_t pbstrFormatName ) { 
    HRESULT _hr = put_FormatName(pbstrFormatName); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQQueueInfo::GetIsTransactional ( ) { 
    short _result; 
    HRESULT _hr = get_IsTransactional(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQQueueInfo::GetPrivLevel ( ) { 
    long _result; 
    HRESULT _hr = get_PrivLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutPrivLevel ( long plPrivLevel ) { 
    HRESULT _hr = put_PrivLevel(plPrivLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo::GetJournal ( ) { 
    long _result; 
    HRESULT _hr = get_Journal(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutJournal ( long plJournal ) { 
    HRESULT _hr = put_Journal(plJournal); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo::GetQuota ( ) { 
    long _result; 
    HRESULT _hr = get_Quota(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutQuota ( long plQuota ) { 
    HRESULT _hr = put_Quota(plQuota); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo::GetBasePriority ( ) { 
    long _result; 
    HRESULT _hr = get_BasePriority(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutBasePriority ( long plBasePriority ) { 
    HRESULT _hr = put_BasePriority(plBasePriority); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQQueueInfo::GetCreateTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_CreateTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQQueueInfo::GetModifyTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_ModifyTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline long IMSMQQueueInfo::GetAuthenticate ( ) { 
    long _result; 
    HRESULT _hr = get_Authenticate(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutAuthenticate ( long plAuthenticate ) { 
    HRESULT _hr = put_Authenticate(plAuthenticate); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo::GetJournalQuota ( ) { 
    long _result; 
    HRESULT _hr = get_JournalQuota(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo::PutJournalQuota ( long plJournalQuota ) { 
    HRESULT _hr = put_JournalQuota(plJournalQuota); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQQueueInfo::GetIsWorldReadable ( ) { 
    short _result; 
    HRESULT _hr = get_IsWorldReadable(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQQueueInfo::Create ( VARIANT * IsTransactional, VARIANT * IsWorldReadable ) { 
    HRESULT _hr = raw_Create(IsTransactional, IsWorldReadable); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueueInfo::Delete ( ) { 
    HRESULT _hr = raw_Delete(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQQueuePtr IMSMQQueueInfo::Open ( long Access, long ShareMode ) { 
    struct IMSMQQueue * _result; 
    HRESULT _hr = raw_Open(Access, ShareMode, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueuePtr(_result, false); 
} 
 
inline HRESULT IMSMQQueueInfo::Refresh ( ) { 
    HRESULT _hr = raw_Refresh(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueueInfo::Update ( ) { 
    HRESULT _hr = raw_Update(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
// 
// interface IMSMQQueue wrapper method implementations 
// 
 
inline long IMSMQQueue::GetAccess ( ) { 
    long _result; 
    HRESULT _hr = get_Access(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQQueue::GetShareMode ( ) { 
    long _result; 
    HRESULT _hr = get_ShareMode(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline IMSMQQueueInfoPtr IMSMQQueue::GetQueueInfo ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_QueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline long IMSMQQueue::GetHandle ( ) { 
    long _result; 
    HRESULT _hr = get_Handle(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline short IMSMQQueue::GetIsOpen ( ) { 
    short _result; 
    HRESULT _hr = get_IsOpen(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQQueue::Close ( ) { 
    HRESULT _hr = raw_Close(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQMessagePtr IMSMQQueue::Receive ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_Receive(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue::Peek ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_Peek(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline HRESULT IMSMQQueue::EnableNotification ( struct IMSMQEvent * Event, VARIANT * Cursor, VARIANT * ReceiveTimeout ) { 
    HRESULT _hr = raw_EnableNotification(Event, Cursor, ReceiveTimeout); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueue::Reset ( ) { 
    HRESULT _hr = raw_Reset(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQMessagePtr IMSMQQueue::ReceiveCurrent ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_ReceiveCurrent(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue::PeekNext ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_PeekNext(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue::PeekCurrent ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_PeekCurrent(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
// 
// interface IMSMQMessage wrapper method implementations 
// 
 
inline long IMSMQMessage::GetClass ( ) { 
    long _result; 
    HRESULT _hr = get_Class(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQMessage::GetPrivLevel ( ) { 
    long _result; 
    HRESULT _hr = get_PrivLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutPrivLevel ( long plPrivLevel ) { 
    HRESULT _hr = put_PrivLevel(plPrivLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetAuthLevel ( ) { 
    long _result; 
    HRESULT _hr = get_AuthLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutAuthLevel ( long plAuthLevel ) { 
    HRESULT _hr = put_AuthLevel(plAuthLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQMessage::GetIsAuthenticated ( ) { 
    short _result; 
    HRESULT _hr = get_IsAuthenticated(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQMessage::GetDelivery ( ) { 
    long _result; 
    HRESULT _hr = get_Delivery(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutDelivery ( long plDelivery ) { 
    HRESULT _hr = put_Delivery(plDelivery); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetTrace ( ) { 
    long _result; 
    HRESULT _hr = get_Trace(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutTrace ( long plTrace ) { 
    HRESULT _hr = put_Trace(plTrace); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetPriority ( ) { 
    long _result; 
    HRESULT _hr = get_Priority(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutPriority ( long plPriority ) { 
    HRESULT _hr = put_Priority(plPriority); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetJournal ( ) { 
    long _result; 
    HRESULT _hr = get_Journal(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutJournal ( long plJournal ) { 
    HRESULT _hr = put_Journal(plJournal); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfoPtr IMSMQMessage::GetResponseQueueInfo ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_ResponseQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline void IMSMQMessage::PutRefResponseQueueInfo ( struct IMSMQQueueInfo * ppqinfoResponse ) { 
    HRESULT _hr = putref_ResponseQueueInfo(ppqinfoResponse); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetAppSpecific ( ) { 
    long _result; 
    HRESULT _hr = get_AppSpecific(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutAppSpecific ( long plAppSpecific ) { 
    HRESULT _hr = put_AppSpecific(plAppSpecific); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage::GetSourceMachineGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_SourceMachineGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline long IMSMQMessage::GetBodyLength ( ) { 
    long _result; 
    HRESULT _hr = get_BodyLength(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline _variant_t IMSMQMessage::GetBody ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Body(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage::PutBody ( const _variant_t & pvarBody ) { 
    HRESULT _hr = put_Body(pvarBody); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfoPtr IMSMQMessage::GetAdminQueueInfo ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_AdminQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline void IMSMQMessage::PutRefAdminQueueInfo ( struct IMSMQQueueInfo * ppqinfoAdmin ) { 
    HRESULT _hr = putref_AdminQueueInfo(ppqinfoAdmin); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage::GetId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Id(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQMessage::GetCorrelationId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_CorrelationId(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage::PutCorrelationId ( const _variant_t & pvarMsgId ) { 
    HRESULT _hr = put_CorrelationId(pvarMsgId); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetAck ( ) { 
    long _result; 
    HRESULT _hr = get_Ack(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutAck ( long plAck ) { 
    HRESULT _hr = put_Ack(plAck); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage::GetLabel ( ) { 
    BSTR _result; 
    HRESULT _hr = get_Label(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQMessage::PutLabel ( _bstr_t pbstrLabel ) { 
    HRESULT _hr = put_Label(pbstrLabel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetMaxTimeToReachQueue ( ) { 
    long _result; 
    HRESULT _hr = get_MaxTimeToReachQueue(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutMaxTimeToReachQueue ( long plMaxTimeToReachQueue ) { 
    HRESULT _hr = put_MaxTimeToReachQueue(plMaxTimeToReachQueue); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetMaxTimeToReceive ( ) { 
    long _result; 
    HRESULT _hr = get_MaxTimeToReceive(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutMaxTimeToReceive ( long plMaxTimeToReceive ) { 
    HRESULT _hr = put_MaxTimeToReceive(plMaxTimeToReceive); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetHashAlgorithm ( ) { 
    long _result; 
    HRESULT _hr = get_HashAlgorithm(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutHashAlgorithm ( long plHashAlg ) { 
    HRESULT _hr = put_HashAlgorithm(plHashAlg); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage::GetEncryptAlgorithm ( ) { 
    long _result; 
    HRESULT _hr = get_EncryptAlgorithm(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutEncryptAlgorithm ( long plEncryptAlg ) { 
    HRESULT _hr = put_EncryptAlgorithm(plEncryptAlg); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage::GetSentTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SentTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQMessage::GetArrivedTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_ArrivedTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline IMSMQQueueInfoPtr IMSMQMessage::GetDestinationQueueInfo ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_DestinationQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline _variant_t IMSMQMessage::GetSenderCertificate ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SenderCertificate(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage::PutSenderCertificate ( const _variant_t & pvarSenderCert ) { 
    HRESULT _hr = put_SenderCertificate(pvarSenderCert); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage::GetSenderId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SenderId(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline long IMSMQMessage::GetSenderIdType ( ) { 
    long _result; 
    HRESULT _hr = get_SenderIdType(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage::PutSenderIdType ( long plSenderIdType ) { 
    HRESULT _hr = put_SenderIdType(plSenderIdType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline HRESULT IMSMQMessage::Send ( struct IMSMQQueue * DestinationQueue, VARIANT * Transaction ) { 
    HRESULT _hr = raw_Send(DestinationQueue, Transaction); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQMessage::AttachCurrentSecurityContext ( ) { 
    HRESULT _hr = raw_AttachCurrentSecurityContext(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
// 
// interface IMSMQQueueInfo2 wrapper method implementations 
// 
 
inline _bstr_t IMSMQQueueInfo2::GetQueueGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_QueueGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline _bstr_t IMSMQQueueInfo2::GetServiceTypeGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_ServiceTypeGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo2::PutServiceTypeGuid ( _bstr_t pbstrGuidServiceType ) { 
    HRESULT _hr = put_ServiceTypeGuid(pbstrGuidServiceType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo2::GetLabel ( ) { 
    BSTR _result; 
    HRESULT _hr = get_Label(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo2::PutLabel ( _bstr_t pbstrLabel ) { 
    HRESULT _hr = put_Label(pbstrLabel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo2::GetPathName ( ) { 
    BSTR _result; 
    HRESULT _hr = get_PathName(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo2::PutPathName ( _bstr_t pbstrPathName ) { 
    HRESULT _hr = put_PathName(pbstrPathName); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQQueueInfo2::GetFormatName ( ) { 
    BSTR _result; 
    HRESULT _hr = get_FormatName(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQQueueInfo2::PutFormatName ( _bstr_t pbstrFormatName ) { 
    HRESULT _hr = put_FormatName(pbstrFormatName); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQQueueInfo2::GetIsTransactional ( ) { 
    short _result; 
    HRESULT _hr = get_IsTransactional(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQQueueInfo2::GetPrivLevel ( ) { 
    long _result; 
    HRESULT _hr = get_PrivLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutPrivLevel ( long plPrivLevel ) { 
    HRESULT _hr = put_PrivLevel(plPrivLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo2::GetJournal ( ) { 
    long _result; 
    HRESULT _hr = get_Journal(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutJournal ( long plJournal ) { 
    HRESULT _hr = put_Journal(plJournal); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo2::GetQuota ( ) { 
    long _result; 
    HRESULT _hr = get_Quota(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutQuota ( long plQuota ) { 
    HRESULT _hr = put_Quota(plQuota); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo2::GetBasePriority ( ) { 
    long _result; 
    HRESULT _hr = get_BasePriority(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutBasePriority ( long plBasePriority ) { 
    HRESULT _hr = put_BasePriority(plBasePriority); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQQueueInfo2::GetCreateTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_CreateTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQQueueInfo2::GetModifyTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_ModifyTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline long IMSMQQueueInfo2::GetAuthenticate ( ) { 
    long _result; 
    HRESULT _hr = get_Authenticate(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutAuthenticate ( long plAuthenticate ) { 
    HRESULT _hr = put_Authenticate(plAuthenticate); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQQueueInfo2::GetJournalQuota ( ) { 
    long _result; 
    HRESULT _hr = get_JournalQuota(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQQueueInfo2::PutJournalQuota ( long plJournalQuota ) { 
    HRESULT _hr = put_JournalQuota(plJournalQuota); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQQueueInfo2::GetIsWorldReadable ( ) { 
    short _result; 
    HRESULT _hr = get_IsWorldReadable(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQQueueInfo2::Create ( VARIANT * IsTransactional, VARIANT * IsWorldReadable ) { 
    HRESULT _hr = raw_Create(IsTransactional, IsWorldReadable); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueueInfo2::Delete ( ) { 
    HRESULT _hr = raw_Delete(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQQueue2Ptr IMSMQQueueInfo2::Open ( long Access, long ShareMode ) { 
    struct IMSMQQueue2 * _result; 
    HRESULT _hr = raw_Open(Access, ShareMode, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueue2Ptr(_result, false); 
} 
 
inline HRESULT IMSMQQueueInfo2::Refresh ( ) { 
    HRESULT _hr = raw_Refresh(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueueInfo2::Update ( ) { 
    HRESULT _hr = raw_Update(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline _bstr_t IMSMQQueueInfo2::GetPathNameDNS ( ) { 
    BSTR _result; 
    HRESULT _hr = get_PathNameDNS(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline IDispatchPtr IMSMQQueueInfo2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
inline _variant_t IMSMQQueueInfo2::GetSecurity ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Security(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQQueueInfo2::PutSecurity ( const _variant_t & pvarSecurity ) { 
    HRESULT _hr = put_Security(pvarSecurity); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
// 
// interface IMSMQQueue2 wrapper method implementations 
// 
 
inline long IMSMQQueue2::GetAccess ( ) { 
    long _result; 
    HRESULT _hr = get_Access(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQQueue2::GetShareMode ( ) { 
    long _result; 
    HRESULT _hr = get_ShareMode(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQQueue2::GetQueueInfo ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = get_QueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline long IMSMQQueue2::GetHandle ( ) { 
    long _result; 
    HRESULT _hr = get_Handle(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline short IMSMQQueue2::GetIsOpen ( ) { 
    short _result; 
    HRESULT _hr = get_IsOpen(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQQueue2::Close ( ) { 
    HRESULT _hr = raw_Close(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQMessagePtr IMSMQQueue2::Receive_v1 ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_Receive_v1(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue2::Peek_v1 ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_Peek_v1(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline HRESULT IMSMQQueue2::EnableNotification ( struct IMSMQEvent2 * Event, VARIANT * Cursor, VARIANT * ReceiveTimeout ) { 
    HRESULT _hr = raw_EnableNotification(Event, Cursor, ReceiveTimeout); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQQueue2::Reset ( ) { 
    HRESULT _hr = raw_Reset(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQMessagePtr IMSMQQueue2::ReceiveCurrent_v1 ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_ReceiveCurrent_v1(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue2::PeekNext_v1 ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_PeekNext_v1(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessagePtr IMSMQQueue2::PeekCurrent_v1 ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout ) { 
    struct IMSMQMessage * _result; 
    HRESULT _hr = raw_PeekCurrent_v1(WantDestinationQueue, WantBody, ReceiveTimeout, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessagePtr(_result, false); 
} 
 
inline IMSMQMessage2Ptr IMSMQQueue2::Receive ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) { 
    struct IMSMQMessage2 * _result; 
    HRESULT _hr = raw_Receive(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessage2Ptr(_result, false); 
} 
 
inline IMSMQMessage2Ptr IMSMQQueue2::Peek ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) { 
    struct IMSMQMessage2 * _result; 
    HRESULT _hr = raw_Peek(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessage2Ptr(_result, false); 
} 
 
inline IMSMQMessage2Ptr IMSMQQueue2::ReceiveCurrent ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) { 
    struct IMSMQMessage2 * _result; 
    HRESULT _hr = raw_ReceiveCurrent(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessage2Ptr(_result, false); 
} 
 
inline IMSMQMessage2Ptr IMSMQQueue2::PeekNext ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) { 
    struct IMSMQMessage2 * _result; 
    HRESULT _hr = raw_PeekNext(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessage2Ptr(_result, false); 
} 
 
inline IMSMQMessage2Ptr IMSMQQueue2::PeekCurrent ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) { 
    struct IMSMQMessage2 * _result; 
    HRESULT _hr = raw_PeekCurrent(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQMessage2Ptr(_result, false); 
} 
 
inline IDispatchPtr IMSMQQueue2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQEvent2 wrapper method implementations 
// 
 
inline IDispatchPtr IMSMQEvent2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQMessage2 wrapper method implementations 
// 
 
inline long IMSMQMessage2::GetClass ( ) { 
    long _result; 
    HRESULT _hr = get_Class(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQMessage2::GetPrivLevel ( ) { 
    long _result; 
    HRESULT _hr = get_PrivLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutPrivLevel ( long plPrivLevel ) { 
    HRESULT _hr = put_PrivLevel(plPrivLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetAuthLevel ( ) { 
    long _result; 
    HRESULT _hr = get_AuthLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutAuthLevel ( long plAuthLevel ) { 
    HRESULT _hr = put_AuthLevel(plAuthLevel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQMessage2::GetIsAuthenticated ( ) { 
    short _result; 
    HRESULT _hr = get_IsAuthenticated(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline long IMSMQMessage2::GetDelivery ( ) { 
    long _result; 
    HRESULT _hr = get_Delivery(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutDelivery ( long plDelivery ) { 
    HRESULT _hr = put_Delivery(plDelivery); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetTrace ( ) { 
    long _result; 
    HRESULT _hr = get_Trace(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutTrace ( long plTrace ) { 
    HRESULT _hr = put_Trace(plTrace); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetPriority ( ) { 
    long _result; 
    HRESULT _hr = get_Priority(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutPriority ( long plPriority ) { 
    HRESULT _hr = put_Priority(plPriority); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetJournal ( ) { 
    long _result; 
    HRESULT _hr = get_Journal(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutJournal ( long plJournal ) { 
    HRESULT _hr = put_Journal(plJournal); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfoPtr IMSMQMessage2::GetResponseQueueInfo_v1 ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_ResponseQueueInfo_v1(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline void IMSMQMessage2::PutRefResponseQueueInfo_v1 ( struct IMSMQQueueInfo * ppqinfoResponse ) { 
    HRESULT _hr = putref_ResponseQueueInfo_v1(ppqinfoResponse); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetAppSpecific ( ) { 
    long _result; 
    HRESULT _hr = get_AppSpecific(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutAppSpecific ( long plAppSpecific ) { 
    HRESULT _hr = put_AppSpecific(plAppSpecific); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage2::GetSourceMachineGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_SourceMachineGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline long IMSMQMessage2::GetBodyLength ( ) { 
    long _result; 
    HRESULT _hr = get_BodyLength(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline _variant_t IMSMQMessage2::GetBody ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Body(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutBody ( const _variant_t & pvarBody ) { 
    HRESULT _hr = put_Body(pvarBody); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfoPtr IMSMQMessage2::GetAdminQueueInfo_v1 ( ) { 
    struct IMSMQQueueInfo * _result; 
    HRESULT _hr = get_AdminQueueInfo_v1(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfoPtr(_result, false); 
} 
 
inline void IMSMQMessage2::PutRefAdminQueueInfo_v1 ( struct IMSMQQueueInfo * ppqinfoAdmin ) { 
    HRESULT _hr = putref_AdminQueueInfo_v1(ppqinfoAdmin); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage2::GetId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Id(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQMessage2::GetCorrelationId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_CorrelationId(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutCorrelationId ( const _variant_t & pvarMsgId ) { 
    HRESULT _hr = put_CorrelationId(pvarMsgId); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetAck ( ) { 
    long _result; 
    HRESULT _hr = get_Ack(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutAck ( long plAck ) { 
    HRESULT _hr = put_Ack(plAck); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage2::GetLabel ( ) { 
    BSTR _result; 
    HRESULT _hr = get_Label(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutLabel ( _bstr_t pbstrLabel ) { 
    HRESULT _hr = put_Label(pbstrLabel); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetMaxTimeToReachQueue ( ) { 
    long _result; 
    HRESULT _hr = get_MaxTimeToReachQueue(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutMaxTimeToReachQueue ( long plMaxTimeToReachQueue ) { 
    HRESULT _hr = put_MaxTimeToReachQueue(plMaxTimeToReachQueue); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetMaxTimeToReceive ( ) { 
    long _result; 
    HRESULT _hr = get_MaxTimeToReceive(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutMaxTimeToReceive ( long plMaxTimeToReceive ) { 
    HRESULT _hr = put_MaxTimeToReceive(plMaxTimeToReceive); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetHashAlgorithm ( ) { 
    long _result; 
    HRESULT _hr = get_HashAlgorithm(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutHashAlgorithm ( long plHashAlg ) { 
    HRESULT _hr = put_HashAlgorithm(plHashAlg); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetEncryptAlgorithm ( ) { 
    long _result; 
    HRESULT _hr = get_EncryptAlgorithm(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutEncryptAlgorithm ( long plEncryptAlg ) { 
    HRESULT _hr = put_EncryptAlgorithm(plEncryptAlg); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage2::GetSentTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SentTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline _variant_t IMSMQMessage2::GetArrivedTime ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_ArrivedTime(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQMessage2::GetDestinationQueueInfo ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = get_DestinationQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline _variant_t IMSMQMessage2::GetSenderCertificate ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SenderCertificate(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutSenderCertificate ( const _variant_t & pvarSenderCert ) { 
    HRESULT _hr = put_SenderCertificate(pvarSenderCert); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage2::GetSenderId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_SenderId(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline long IMSMQMessage2::GetSenderIdType ( ) { 
    long _result; 
    HRESULT _hr = get_SenderIdType(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutSenderIdType ( long plSenderIdType ) { 
    HRESULT _hr = put_SenderIdType(plSenderIdType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline HRESULT IMSMQMessage2::Send ( struct IMSMQQueue2 * DestinationQueue, VARIANT * Transaction ) { 
    HRESULT _hr = raw_Send(DestinationQueue, Transaction); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQMessage2::AttachCurrentSecurityContext ( ) { 
    HRESULT _hr = raw_AttachCurrentSecurityContext(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline long IMSMQMessage2::GetSenderVersion ( ) { 
    long _result; 
    HRESULT _hr = get_SenderVersion(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline _variant_t IMSMQMessage2::GetExtension ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Extension(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutExtension ( const _variant_t & pvarExtension ) { 
    HRESULT _hr = put_Extension(pvarExtension); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage2::GetConnectorTypeGuid ( ) { 
    BSTR _result; 
    HRESULT _hr = get_ConnectorTypeGuid(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutConnectorTypeGuid ( _bstr_t pbstrGuidConnectorType ) { 
    HRESULT _hr = put_ConnectorTypeGuid(pbstrGuidConnectorType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQMessage2::GetTransactionStatusQueueInfo ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = get_TransactionStatusQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline _variant_t IMSMQMessage2::GetDestinationSymmetricKey ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_DestinationSymmetricKey(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutDestinationSymmetricKey ( const _variant_t & pvarDestSymmKey ) { 
    HRESULT _hr = put_DestinationSymmetricKey(pvarDestSymmKey); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _variant_t IMSMQMessage2::GetSignature ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_Signature(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutSignature ( const _variant_t & pvarSignature ) { 
    HRESULT _hr = put_Signature(pvarSignature); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetAuthenticationProviderType ( ) { 
    long _result; 
    HRESULT _hr = get_AuthenticationProviderType(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutAuthenticationProviderType ( long plAuthProvType ) { 
    HRESULT _hr = put_AuthenticationProviderType(plAuthProvType); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline _bstr_t IMSMQMessage2::GetAuthenticationProviderName ( ) { 
    BSTR _result; 
    HRESULT _hr = get_AuthenticationProviderName(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline void IMSMQMessage2::PutAuthenticationProviderName ( _bstr_t pbstrAuthProvName ) { 
    HRESULT _hr = put_AuthenticationProviderName(pbstrAuthProvName); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline void IMSMQMessage2::PutSenderId ( const _variant_t & pvarSenderId ) { 
    HRESULT _hr = put_SenderId(pvarSenderId); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline long IMSMQMessage2::GetMsgClass ( ) { 
    long _result; 
    HRESULT _hr = get_MsgClass(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline void IMSMQMessage2::PutMsgClass ( long plMsgClass ) { 
    HRESULT _hr = put_MsgClass(plMsgClass); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IDispatchPtr IMSMQMessage2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
inline _variant_t IMSMQMessage2::GetTransactionId ( ) { 
    VARIANT _result; 
    VariantInit(&_result); 
    HRESULT _hr = get_TransactionId(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _variant_t(_result, false); 
} 
 
inline short IMSMQMessage2::GetIsFirstInTransaction ( ) { 
    short _result; 
    HRESULT _hr = get_IsFirstInTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline short IMSMQMessage2::GetIsLastInTransaction ( ) { 
    short _result; 
    HRESULT _hr = get_IsLastInTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQMessage2::GetResponseQueueInfo ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = get_ResponseQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline void IMSMQMessage2::PutRefResponseQueueInfo ( struct IMSMQQueueInfo2 * ppqinfoResponse ) { 
    HRESULT _hr = putref_ResponseQueueInfo(ppqinfoResponse); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQMessage2::GetAdminQueueInfo ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = get_AdminQueueInfo(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline void IMSMQMessage2::PutRefAdminQueueInfo ( struct IMSMQQueueInfo2 * ppqinfoAdmin ) { 
    HRESULT _hr = putref_AdminQueueInfo(ppqinfoAdmin); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
} 
 
inline short IMSMQMessage2::GetReceivedAuthenticationLevel ( ) { 
    short _result; 
    HRESULT _hr = get_ReceivedAuthenticationLevel(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
// 
// interface IMSMQQueueInfos2 wrapper method implementations 
// 
 
inline HRESULT IMSMQQueueInfos2::Reset ( ) { 
    HRESULT _hr = raw_Reset(); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IMSMQQueueInfo2Ptr IMSMQQueueInfos2::Next ( ) { 
    struct IMSMQQueueInfo2 * _result; 
    HRESULT _hr = raw_Next(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfo2Ptr(_result, false); 
} 
 
inline IDispatchPtr IMSMQQueueInfos2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQTransaction wrapper method implementations 
// 
 
inline long IMSMQTransaction::GetTransaction ( ) { 
    long _result; 
    HRESULT _hr = get_Transaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQTransaction::Commit ( VARIANT * fRetaining, VARIANT * grfTC, VARIANT * grfRM ) { 
    HRESULT _hr = raw_Commit(fRetaining, grfTC, grfRM); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQTransaction::Abort ( VARIANT * fRetaining, VARIANT * fAsync ) { 
    HRESULT _hr = raw_Abort(fRetaining, fAsync); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
// 
// interface IMSMQCoordinatedTransactionDispenser wrapper method implementations 
// 
 
inline IMSMQTransactionPtr IMSMQCoordinatedTransactionDispenser::BeginTransaction ( ) { 
    struct IMSMQTransaction * _result; 
    HRESULT _hr = raw_BeginTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQTransactionPtr(_result, false); 
} 
 
// 
// interface IMSMQTransactionDispenser wrapper method implementations 
// 
 
inline IMSMQTransactionPtr IMSMQTransactionDispenser::BeginTransaction ( ) { 
    struct IMSMQTransaction * _result; 
    HRESULT _hr = raw_BeginTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQTransactionPtr(_result, false); 
} 
 
// 
// interface IMSMQQuery2 wrapper method implementations 
// 
 
inline IMSMQQueueInfos2Ptr IMSMQQuery2::LookupQueue ( VARIANT * QueueGuid, VARIANT * ServiceTypeGuid, VARIANT * Label, VARIANT * CreateTime, VARIANT * ModifyTime, VARIANT * RelServiceType, VARIANT * RelLabel, VARIANT * RelCreateTime, VARIANT * RelModifyTime ) { 
    struct IMSMQQueueInfos2 * _result; 
    HRESULT _hr = raw_LookupQueue(QueueGuid, ServiceTypeGuid, Label, CreateTime, ModifyTime, RelServiceType, RelLabel, RelCreateTime, RelModifyTime, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQQueueInfos2Ptr(_result, false); 
} 
 
inline IDispatchPtr IMSMQQuery2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQPrivateEvent wrapper method implementations 
// 
 
inline long IMSMQPrivateEvent::GetHwnd ( ) { 
    long _result; 
    HRESULT _hr = get_Hwnd(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline HRESULT IMSMQPrivateEvent::FireArrivedEvent ( struct IMSMQQueue * pq, long msgcursor ) { 
    HRESULT _hr = raw_FireArrivedEvent(pq, msgcursor); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline HRESULT IMSMQPrivateEvent::FireArrivedErrorEvent ( struct IMSMQQueue * pq, HRESULT hrStatus, long msgcursor ) { 
    HRESULT _hr = raw_FireArrivedErrorEvent(pq, hrStatus, msgcursor); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
// 
// dispinterface _DMSMQEventEvents wrapper method implementations 
// 
 
inline HRESULT _DMSMQEventEvents::Arrived ( IDispatch * Queue, long Cursor ) { 
    return _com_dispatch_method(this, 0x0, DISPATCH_METHOD, VT_EMPTY, NULL,  
        L"\x0009\x0003", Queue, Cursor); 
} 
 
inline HRESULT _DMSMQEventEvents::ArrivedError ( IDispatch * Queue, long ErrorCode, long Cursor ) { 
    return _com_dispatch_method(this, 0x1, DISPATCH_METHOD, VT_EMPTY, NULL,  
        L"\x0009\x0003\x0003", Queue, ErrorCode, Cursor); 
} 
 
// 
// interface IMSMQTransaction2 wrapper method implementations 
// 
 
inline HRESULT IMSMQTransaction2::InitNew ( const _variant_t & varTransaction ) { 
    HRESULT _hr = raw_InitNew(varTransaction); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline IDispatchPtr IMSMQTransaction2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQCoordinatedTransactionDispenser2 wrapper method implementations 
// 
 
inline IMSMQTransaction2Ptr IMSMQCoordinatedTransactionDispenser2::BeginTransaction ( ) { 
    struct IMSMQTransaction2 * _result; 
    HRESULT _hr = raw_BeginTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQTransaction2Ptr(_result, false); 
} 
 
inline IDispatchPtr IMSMQCoordinatedTransactionDispenser2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQTransactionDispenser2 wrapper method implementations 
// 
 
inline IMSMQTransaction2Ptr IMSMQTransactionDispenser2::BeginTransaction ( ) { 
    struct IMSMQTransaction2 * _result; 
    HRESULT _hr = raw_BeginTransaction(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IMSMQTransaction2Ptr(_result, false); 
} 
 
inline IDispatchPtr IMSMQTransactionDispenser2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
} 
 
// 
// interface IMSMQApplication wrapper method implementations 
// 
 
inline _bstr_t IMSMQApplication::MachineIdOfMachineName ( _bstr_t MachineName ) { 
    BSTR _result; 
    HRESULT _hr = raw_MachineIdOfMachineName(MachineName, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
// 
// interface IMSMQApplication2 wrapper method implementations 
// 
 
inline HRESULT IMSMQApplication2::RegisterCertificate ( VARIANT * Flags, VARIANT * ExternalCertificate ) { 
    HRESULT _hr = raw_RegisterCertificate(Flags, ExternalCertificate); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _hr; 
} 
 
inline _bstr_t IMSMQApplication2::MachineNameOfMachineId ( _bstr_t bstrGuid ) { 
    BSTR _result; 
    HRESULT _hr = raw_MachineNameOfMachineId(bstrGuid, &_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _bstr_t(_result, false); 
} 
 
inline short IMSMQApplication2::GetMSMQVersionMajor ( ) { 
    short _result; 
    HRESULT _hr = get_MSMQVersionMajor(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline short IMSMQApplication2::GetMSMQVersionMinor ( ) { 
    short _result; 
    HRESULT _hr = get_MSMQVersionMinor(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline short IMSMQApplication2::GetMSMQVersionBuild ( ) { 
    short _result; 
    HRESULT _hr = get_MSMQVersionBuild(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline VARIANT_BOOL IMSMQApplication2::GetIsDsEnabled ( ) { 
    VARIANT_BOOL _result; 
    HRESULT _hr = get_IsDsEnabled(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return _result; 
} 
 
inline IDispatchPtr IMSMQApplication2::GetProperties ( ) { 
    IDispatch * _result; 
    HRESULT _hr = get_Properties(&_result); 
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this)); 
    return IDispatchPtr(_result, false); 
}