windows-server-2003/sdktools/debuggers/oca/services/centralfmsvc/mqoa.tli

// Created by Microsoft (R) C/C++ Compiler Version 12.00.8447.0 (22b11824).
//
// mqoa.tli
//
// Wrapper implementations for Win32 type library d:\\windows\\system32\\mqoa.dll
// compiler-generated file created 11/07/01 at 11:59:44 - 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 IMSMQQueueInfo3 wrapper method implementations
//

inline _bstr_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::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 IMSMQQueueInfo3::PutServiceTypeGuid ( _bstr_t pbstrGuidServiceType ) {
    HRESULT _hr = put_ServiceTypeGuid(pbstrGuidServiceType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::PutLabel ( _bstr_t pbstrLabel ) {
    HRESULT _hr = put_Label(pbstrLabel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::PutPathName ( _bstr_t pbstrPathName ) {
    HRESULT _hr = put_PathName(pbstrPathName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::PutFormatName ( _bstr_t pbstrFormatName ) {
    HRESULT _hr = put_FormatName(pbstrFormatName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline short IMSMQQueueInfo3::GetIsTransactional ( ) {
    short _result;
    HRESULT _hr = get_IsTransactional(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQQueueInfo3::GetPrivLevel ( ) {
    long _result;
    HRESULT _hr = get_PrivLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutPrivLevel ( long plPrivLevel ) {
    HRESULT _hr = put_PrivLevel(plPrivLevel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQQueueInfo3::GetJournal ( ) {
    long _result;
    HRESULT _hr = get_Journal(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutJournal ( long plJournal ) {
    HRESULT _hr = put_Journal(plJournal);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQQueueInfo3::GetQuota ( ) {
    long _result;
    HRESULT _hr = get_Quota(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutQuota ( long plQuota ) {
    HRESULT _hr = put_Quota(plQuota);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQQueueInfo3::GetBasePriority ( ) {
    long _result;
    HRESULT _hr = get_BasePriority(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutBasePriority ( long plBasePriority ) {
    HRESULT _hr = put_BasePriority(plBasePriority);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::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 IMSMQQueueInfo3::GetAuthenticate ( ) {
    long _result;
    HRESULT _hr = get_Authenticate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutAuthenticate ( long plAuthenticate ) {
    HRESULT _hr = put_Authenticate(plAuthenticate);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQQueueInfo3::GetJournalQuota ( ) {
    long _result;
    HRESULT _hr = get_JournalQuota(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQQueueInfo3::PutJournalQuota ( long plJournalQuota ) {
    HRESULT _hr = put_JournalQuota(plJournalQuota);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline short IMSMQQueueInfo3::GetIsWorldReadable ( ) {
    short _result;
    HRESULT _hr = get_IsWorldReadable(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IMSMQQueueInfo3::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 IMSMQQueueInfo3::Delete ( ) {
    HRESULT _hr = raw_Delete();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IMSMQQueue3Ptr IMSMQQueueInfo3::Open ( long Access, long ShareMode ) {
    struct IMSMQQueue3 * _result;
    HRESULT _hr = raw_Open(Access, ShareMode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueue3Ptr(_result, false);
}

inline HRESULT IMSMQQueueInfo3::Refresh ( ) {
    HRESULT _hr = raw_Refresh();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQQueueInfo3::Update ( ) {
    HRESULT _hr = raw_Update();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _bstr_t IMSMQQueueInfo3::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 IMSMQQueueInfo3::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 IMSMQQueueInfo3::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 IMSMQQueueInfo3::PutSecurity ( const _variant_t & pvarSecurity ) {
    HRESULT _hr = put_Security(pvarSecurity);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMSMQQueueInfo3::GetIsTransactional2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsTransactional2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL IMSMQQueueInfo3::GetIsWorldReadable2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsWorldReadable2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IMSMQQueueInfo3::GetMulticastAddress ( ) {
    BSTR _result;
    HRESULT _hr = get_MulticastAddress(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IMSMQQueueInfo3::PutMulticastAddress ( _bstr_t pbstrMulticastAddress ) {
    HRESULT _hr = put_MulticastAddress(pbstrMulticastAddress);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQQueueInfo3::GetADsPath ( ) {
    BSTR _result;
    HRESULT _hr = get_ADsPath(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IMSMQQueue3 wrapper method implementations
//

inline long IMSMQQueue3::GetAccess ( ) {
    long _result;
    HRESULT _hr = get_Access(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQQueue3::GetShareMode ( ) {
    long _result;
    HRESULT _hr = get_ShareMode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IMSMQQueueInfo3Ptr IMSMQQueue3::GetQueueInfo ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = get_QueueInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline long IMSMQQueue3::GetHandle ( ) {
    long _result;
    HRESULT _hr = get_Handle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline short IMSMQQueue3::GetIsOpen ( ) {
    short _result;
    HRESULT _hr = get_IsOpen(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IMSMQQueue3::Close ( ) {
    HRESULT _hr = raw_Close();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IMSMQMessagePtr IMSMQQueue3::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 IMSMQQueue3::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 IMSMQQueue3::EnableNotification ( struct IMSMQEvent3 * 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 IMSMQQueue3::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IMSMQMessagePtr IMSMQQueue3::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 IMSMQQueue3::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 IMSMQQueue3::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 IMSMQMessage3Ptr IMSMQQueue3::Receive ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_Receive(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::Peek ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_Peek(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceiveCurrent ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceiveCurrent(Transaction, WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekNext ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekNext(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekCurrent ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * ReceiveTimeout, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekCurrent(WantDestinationQueue, WantBody, ReceiveTimeout, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IDispatchPtr IMSMQQueue3::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 IMSMQQueue3::GetHandle2 ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_Handle2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceiveByLookupId ( const _variant_t & LookupId, VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceiveByLookupId(LookupId, Transaction, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceiveNextByLookupId ( const _variant_t & LookupId, VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceiveNextByLookupId(LookupId, Transaction, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceivePreviousByLookupId ( const _variant_t & LookupId, VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceivePreviousByLookupId(LookupId, Transaction, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceiveFirstByLookupId ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceiveFirstByLookupId(Transaction, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::ReceiveLastByLookupId ( VARIANT * Transaction, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_ReceiveLastByLookupId(Transaction, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekByLookupId ( const _variant_t & LookupId, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekByLookupId(LookupId, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekNextByLookupId ( const _variant_t & LookupId, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekNextByLookupId(LookupId, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekPreviousByLookupId ( const _variant_t & LookupId, VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekPreviousByLookupId(LookupId, WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekFirstByLookupId ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekFirstByLookupId(WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline IMSMQMessage3Ptr IMSMQQueue3::PeekLastByLookupId ( VARIANT * WantDestinationQueue, VARIANT * WantBody, VARIANT * WantConnectorType ) {
    struct IMSMQMessage3 * _result;
    HRESULT _hr = raw_PeekLastByLookupId(WantDestinationQueue, WantBody, WantConnectorType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQMessage3Ptr(_result, false);
}

inline HRESULT IMSMQQueue3::Purge ( ) {
    HRESULT _hr = raw_Purge();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL IMSMQQueue3::GetIsOpen2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsOpen2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface IMSMQMessage3 wrapper method implementations
//

inline long IMSMQMessage3::GetClass ( ) {
    long _result;
    HRESULT _hr = get_Class(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQMessage3::GetPrivLevel ( ) {
    long _result;
    HRESULT _hr = get_PrivLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutPrivLevel ( long plPrivLevel ) {
    HRESULT _hr = put_PrivLevel(plPrivLevel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetAuthLevel ( ) {
    long _result;
    HRESULT _hr = get_AuthLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutAuthLevel ( long plAuthLevel ) {
    HRESULT _hr = put_AuthLevel(plAuthLevel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline short IMSMQMessage3::GetIsAuthenticated ( ) {
    short _result;
    HRESULT _hr = get_IsAuthenticated(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQMessage3::GetDelivery ( ) {
    long _result;
    HRESULT _hr = get_Delivery(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutDelivery ( long plDelivery ) {
    HRESULT _hr = put_Delivery(plDelivery);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetTrace ( ) {
    long _result;
    HRESULT _hr = get_Trace(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutTrace ( long plTrace ) {
    HRESULT _hr = put_Trace(plTrace);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetPriority ( ) {
    long _result;
    HRESULT _hr = get_Priority(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutPriority ( long plPriority ) {
    HRESULT _hr = put_Priority(plPriority);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetJournal ( ) {
    long _result;
    HRESULT _hr = get_Journal(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutJournal ( long plJournal ) {
    HRESULT _hr = put_Journal(plJournal);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMSMQQueueInfoPtr IMSMQMessage3::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 IMSMQMessage3::PutRefResponseQueueInfo_v1 ( struct IMSMQQueueInfo * ppqinfoResponse ) {
    HRESULT _hr = putref_ResponseQueueInfo_v1(ppqinfoResponse);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetAppSpecific ( ) {
    long _result;
    HRESULT _hr = get_AppSpecific(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutAppSpecific ( long plAppSpecific ) {
    HRESULT _hr = put_AppSpecific(plAppSpecific);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQMessage3::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 IMSMQMessage3::GetBodyLength ( ) {
    long _result;
    HRESULT _hr = get_BodyLength(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::PutBody ( const _variant_t & pvarBody ) {
    HRESULT _hr = put_Body(pvarBody);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMSMQQueueInfoPtr IMSMQMessage3::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 IMSMQMessage3::PutRefAdminQueueInfo_v1 ( struct IMSMQQueueInfo * ppqinfoAdmin ) {
    HRESULT _hr = putref_AdminQueueInfo_v1(ppqinfoAdmin);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::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 IMSMQMessage3::PutCorrelationId ( const _variant_t & pvarMsgId ) {
    HRESULT _hr = put_CorrelationId(pvarMsgId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetAck ( ) {
    long _result;
    HRESULT _hr = get_Ack(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutAck ( long plAck ) {
    HRESULT _hr = put_Ack(plAck);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQMessage3::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 IMSMQMessage3::PutLabel ( _bstr_t pbstrLabel ) {
    HRESULT _hr = put_Label(pbstrLabel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetMaxTimeToReachQueue ( ) {
    long _result;
    HRESULT _hr = get_MaxTimeToReachQueue(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutMaxTimeToReachQueue ( long plMaxTimeToReachQueue ) {
    HRESULT _hr = put_MaxTimeToReachQueue(plMaxTimeToReachQueue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetMaxTimeToReceive ( ) {
    long _result;
    HRESULT _hr = get_MaxTimeToReceive(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutMaxTimeToReceive ( long plMaxTimeToReceive ) {
    HRESULT _hr = put_MaxTimeToReceive(plMaxTimeToReceive);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetHashAlgorithm ( ) {
    long _result;
    HRESULT _hr = get_HashAlgorithm(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutHashAlgorithm ( long plHashAlg ) {
    HRESULT _hr = put_HashAlgorithm(plHashAlg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetEncryptAlgorithm ( ) {
    long _result;
    HRESULT _hr = get_EncryptAlgorithm(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutEncryptAlgorithm ( long plEncryptAlg ) {
    HRESULT _hr = put_EncryptAlgorithm(plEncryptAlg);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::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 IMSMQQueueInfo3Ptr IMSMQMessage3::GetDestinationQueueInfo ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = get_DestinationQueueInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::PutSenderCertificate ( const _variant_t & pvarSenderCert ) {
    HRESULT _hr = put_SenderCertificate(pvarSenderCert);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::GetSenderIdType ( ) {
    long _result;
    HRESULT _hr = get_SenderIdType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutSenderIdType ( long plSenderIdType ) {
    HRESULT _hr = put_SenderIdType(plSenderIdType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMSMQMessage3::Send ( IDispatch * DestinationQueue, VARIANT * Transaction ) {
    HRESULT _hr = raw_Send(DestinationQueue, Transaction);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQMessage3::AttachCurrentSecurityContext ( ) {
    HRESULT _hr = raw_AttachCurrentSecurityContext();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline long IMSMQMessage3::GetSenderVersion ( ) {
    long _result;
    HRESULT _hr = get_SenderVersion(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::PutExtension ( const _variant_t & pvarExtension ) {
    HRESULT _hr = put_Extension(pvarExtension);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQMessage3::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 IMSMQMessage3::PutConnectorTypeGuid ( _bstr_t pbstrGuidConnectorType ) {
    HRESULT _hr = put_ConnectorTypeGuid(pbstrGuidConnectorType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMSMQQueueInfo3Ptr IMSMQMessage3::GetTransactionStatusQueueInfo ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = get_TransactionStatusQueueInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::PutDestinationSymmetricKey ( const _variant_t & pvarDestSymmKey ) {
    HRESULT _hr = put_DestinationSymmetricKey(pvarDestSymmKey);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMSMQMessage3::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 IMSMQMessage3::PutSignature ( const _variant_t & pvarSignature ) {
    HRESULT _hr = put_Signature(pvarSignature);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetAuthenticationProviderType ( ) {
    long _result;
    HRESULT _hr = get_AuthenticationProviderType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutAuthenticationProviderType ( long plAuthProvType ) {
    HRESULT _hr = put_AuthenticationProviderType(plAuthProvType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQMessage3::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 IMSMQMessage3::PutAuthenticationProviderName ( _bstr_t pbstrAuthProvName ) {
    HRESULT _hr = put_AuthenticationProviderName(pbstrAuthProvName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline void IMSMQMessage3::PutSenderId ( const _variant_t & pvarSenderId ) {
    HRESULT _hr = put_SenderId(pvarSenderId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMSMQMessage3::GetMsgClass ( ) {
    long _result;
    HRESULT _hr = get_MsgClass(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMSMQMessage3::PutMsgClass ( long plMsgClass ) {
    HRESULT _hr = put_MsgClass(plMsgClass);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IDispatchPtr IMSMQMessage3::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 IMSMQMessage3::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 IMSMQMessage3::GetIsFirstInTransaction ( ) {
    short _result;
    HRESULT _hr = get_IsFirstInTransaction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline short IMSMQMessage3::GetIsLastInTransaction ( ) {
    short _result;
    HRESULT _hr = get_IsLastInTransaction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IMSMQQueueInfo2Ptr IMSMQMessage3::GetResponseQueueInfo_v2 ( ) {
    struct IMSMQQueueInfo2 * _result;
    HRESULT _hr = get_ResponseQueueInfo_v2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo2Ptr(_result, false);
}

inline void IMSMQMessage3::PutRefResponseQueueInfo_v2 ( struct IMSMQQueueInfo2 * ppqinfoResponse ) {
    HRESULT _hr = putref_ResponseQueueInfo_v2(ppqinfoResponse);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMSMQQueueInfo2Ptr IMSMQMessage3::GetAdminQueueInfo_v2 ( ) {
    struct IMSMQQueueInfo2 * _result;
    HRESULT _hr = get_AdminQueueInfo_v2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo2Ptr(_result, false);
}

inline void IMSMQMessage3::PutRefAdminQueueInfo_v2 ( struct IMSMQQueueInfo2 * ppqinfoAdmin ) {
    HRESULT _hr = putref_AdminQueueInfo_v2(ppqinfoAdmin);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline short IMSMQMessage3::GetReceivedAuthenticationLevel ( ) {
    short _result;
    HRESULT _hr = get_ReceivedAuthenticationLevel(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IMSMQQueueInfo3Ptr IMSMQMessage3::GetResponseQueueInfo ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = get_ResponseQueueInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline void IMSMQMessage3::PutRefResponseQueueInfo ( struct IMSMQQueueInfo3 * ppqinfoResponse ) {
    HRESULT _hr = putref_ResponseQueueInfo(ppqinfoResponse);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMSMQQueueInfo3Ptr IMSMQMessage3::GetAdminQueueInfo ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = get_AdminQueueInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline void IMSMQMessage3::PutRefAdminQueueInfo ( struct IMSMQQueueInfo3 * ppqinfoAdmin ) {
    HRESULT _hr = putref_AdminQueueInfo(ppqinfoAdmin);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IDispatchPtr IMSMQMessage3::GetResponseDestination ( ) {
    IDispatch * _result;
    HRESULT _hr = get_ResponseDestination(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline void IMSMQMessage3::PutRefResponseDestination ( IDispatch * ppdestResponse ) {
    HRESULT _hr = putref_ResponseDestination(ppdestResponse);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IDispatchPtr IMSMQMessage3::GetDestination ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Destination(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline _variant_t IMSMQMessage3::GetLookupId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_LookupId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline VARIANT_BOOL IMSMQMessage3::GetIsAuthenticated2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsAuthenticated2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL IMSMQMessage3::GetIsFirstInTransaction2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsFirstInTransaction2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL IMSMQMessage3::GetIsLastInTransaction2 ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsLastInTransaction2(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IMSMQMessage3::AttachCurrentSecurityContext2 ( ) {
    HRESULT _hr = raw_AttachCurrentSecurityContext2();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _bstr_t IMSMQMessage3::GetSoapEnvelope ( ) {
    BSTR _result;
    HRESULT _hr = get_SoapEnvelope(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _variant_t IMSMQMessage3::GetCompoundMessage ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_CompoundMessage(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IMSMQMessage3::PutSoapHeader ( _bstr_t _arg1 ) {
    HRESULT _hr = put_SoapHeader(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline void IMSMQMessage3::PutSoapBody ( _bstr_t _arg1 ) {
    HRESULT _hr = put_SoapBody(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// 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 IMSMQQueueInfos3 wrapper method implementations
//

inline HRESULT IMSMQQueueInfos3::Reset ( ) {
    HRESULT _hr = raw_Reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IMSMQQueueInfo3Ptr IMSMQQueueInfos3::Next ( ) {
    struct IMSMQQueueInfo3 * _result;
    HRESULT _hr = raw_Next(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfo3Ptr(_result, false);
}

inline IDispatchPtr IMSMQQueueInfos3::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 IMSMQQuery3 wrapper method implementations
//

inline IMSMQQueueInfos3Ptr IMSMQQuery3::LookupQueue_v2 ( VARIANT * QueueGuid, VARIANT * ServiceTypeGuid, VARIANT * Label, VARIANT * CreateTime, VARIANT * ModifyTime, VARIANT * RelServiceType, VARIANT * RelLabel, VARIANT * RelCreateTime, VARIANT * RelModifyTime ) {
    struct IMSMQQueueInfos3 * _result;
    HRESULT _hr = raw_LookupQueue_v2(QueueGuid, ServiceTypeGuid, Label, CreateTime, ModifyTime, RelServiceType, RelLabel, RelCreateTime, RelModifyTime, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfos3Ptr(_result, false);
}

inline IDispatchPtr IMSMQQuery3::GetProperties ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Properties(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline IMSMQQueueInfos3Ptr IMSMQQuery3::LookupQueue ( VARIANT * QueueGuid, VARIANT * ServiceTypeGuid, VARIANT * Label, VARIANT * CreateTime, VARIANT * ModifyTime, VARIANT * RelServiceType, VARIANT * RelLabel, VARIANT * RelCreateTime, VARIANT * RelModifyTime, VARIANT * MulticastAddress, VARIANT * RelMulticastAddress ) {
    struct IMSMQQueueInfos3 * _result;
    HRESULT _hr = raw_LookupQueue(QueueGuid, ServiceTypeGuid, Label, CreateTime, ModifyTime, RelServiceType, RelLabel, RelCreateTime, RelModifyTime, MulticastAddress, RelMulticastAddress, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQQueueInfos3Ptr(_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 IMSMQTransaction3 wrapper method implementations
//

inline _variant_t IMSMQTransaction3::GetITransaction ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_ITransaction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_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 IMSMQCoordinatedTransactionDispenser3 wrapper method implementations
//

inline IMSMQTransaction3Ptr IMSMQCoordinatedTransactionDispenser3::BeginTransaction ( ) {
    struct IMSMQTransaction3 * _result;
    HRESULT _hr = raw_BeginTransaction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQTransaction3Ptr(_result, false);
}

inline IDispatchPtr IMSMQCoordinatedTransactionDispenser3::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 IMSMQTransactionDispenser3 wrapper method implementations
//

inline IMSMQTransaction3Ptr IMSMQTransactionDispenser3::BeginTransaction ( ) {
    struct IMSMQTransaction3 * _result;
    HRESULT _hr = raw_BeginTransaction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQTransaction3Ptr(_result, false);
}

inline IDispatchPtr IMSMQTransactionDispenser3::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);
}

//
// interface IMSMQApplication3 wrapper method implementations
//

inline _variant_t IMSMQApplication3::GetActiveQueues ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_ActiveQueues(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _variant_t IMSMQApplication3::GetPrivateQueues ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_PrivateQueues(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _bstr_t IMSMQApplication3::GetDirectoryServiceServer ( ) {
    BSTR _result;
    HRESULT _hr = get_DirectoryServiceServer(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline VARIANT_BOOL IMSMQApplication3::GetIsConnected ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsConnected(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQApplication3::GetBytesInAllQueues ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_BytesInAllQueues(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IMSMQApplication3::PutMachine ( _bstr_t pbstrMachine ) {
    HRESULT _hr = put_Machine(pbstrMachine);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQApplication3::GetMachine ( ) {
    BSTR _result;
    HRESULT _hr = get_Machine(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline HRESULT IMSMQApplication3::Connect ( ) {
    HRESULT _hr = raw_Connect();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQApplication3::Disconnect ( ) {
    HRESULT _hr = raw_Disconnect();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQApplication3::Tidy ( ) {
    HRESULT _hr = raw_Tidy();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IMSMQDestination wrapper method implementations
//

inline HRESULT IMSMQDestination::Open ( ) {
    HRESULT _hr = raw_Open();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQDestination::Close ( ) {
    HRESULT _hr = raw_Close();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL IMSMQDestination::GetIsOpen ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsOpen(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IDispatchPtr IMSMQDestination::GetIADs ( ) {
    IDispatch * _result;
    HRESULT _hr = get_IADs(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline void IMSMQDestination::PutRefIADs ( IDispatch * ppIADs ) {
    HRESULT _hr = putref_IADs(ppIADs);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQDestination::GetADsPath ( ) {
    BSTR _result;
    HRESULT _hr = get_ADsPath(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IMSMQDestination::PutADsPath ( _bstr_t pbstrADsPath ) {
    HRESULT _hr = put_ADsPath(pbstrADsPath);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQDestination::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 IMSMQDestination::PutPathName ( _bstr_t pbstrPathName ) {
    HRESULT _hr = put_PathName(pbstrPathName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMSMQDestination::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 IMSMQDestination::PutFormatName ( _bstr_t pbstrFormatName ) {
    HRESULT _hr = put_FormatName(pbstrFormatName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IDispatchPtr IMSMQDestination::GetDestinations ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Destinations(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline void IMSMQDestination::PutRefDestinations ( IDispatch * ppDestinations ) {
    HRESULT _hr = putref_Destinations(ppDestinations);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IDispatchPtr IMSMQDestination::GetProperties ( ) {
    IDispatch * _result;
    HRESULT _hr = get_Properties(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

//
// interface IMSMQPrivateDestination wrapper method implementations
//

inline _variant_t IMSMQPrivateDestination::GetHandle ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_Handle(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IMSMQPrivateDestination::PutHandle ( const _variant_t & pvarHandle ) {
    HRESULT _hr = put_Handle(pvarHandle);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IMSMQCollection wrapper method implementations
//

inline _variant_t IMSMQCollection::Item ( VARIANT * Index ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_Item(Index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline long IMSMQCollection::GetCount ( ) {
    long _result;
    HRESULT _hr = get_Count(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IUnknownPtr IMSMQCollection::_NewEnum ( ) {
    IUnknown * _result;
    HRESULT _hr = raw__NewEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

//
// interface IMSMQManagement wrapper method implementations
//

inline HRESULT IMSMQManagement::Init ( VARIANT * Machine, VARIANT * PathName, VARIANT * FormatName ) {
    HRESULT _hr = raw_Init(Machine, PathName, FormatName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _bstr_t IMSMQManagement::GetFormatName ( ) {
    BSTR _result;
    HRESULT _hr = get_FormatName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IMSMQManagement::GetMachine ( ) {
    BSTR _result;
    HRESULT _hr = get_Machine(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline long IMSMQManagement::GetMessageCount ( ) {
    long _result;
    HRESULT _hr = get_MessageCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQManagement::GetForeignStatus ( ) {
    long _result;
    HRESULT _hr = get_ForeignStatus(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQManagement::GetQueueType ( ) {
    long _result;
    HRESULT _hr = get_QueueType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL IMSMQManagement::GetIsLocal ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_IsLocal(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IMSMQManagement::GetTransactionalStatus ( ) {
    long _result;
    HRESULT _hr = get_TransactionalStatus(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQManagement::GetBytesInQueue ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_BytesInQueue(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

//
// interface IMSMQOutgoingQueueManagement wrapper method implementations
//

inline long IMSMQOutgoingQueueManagement::GetState ( ) {
    long _result;
    HRESULT _hr = get_State(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQOutgoingQueueManagement::GetNextHops ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_NextHops(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline IMSMQCollectionPtr IMSMQOutgoingQueueManagement::EodGetSendInfo ( ) {
    struct IMSMQCollection * _result;
    HRESULT _hr = raw_EodGetSendInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IMSMQCollectionPtr(_result, false);
}

inline HRESULT IMSMQOutgoingQueueManagement::Resume ( ) {
    HRESULT _hr = raw_Resume();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQOutgoingQueueManagement::Pause ( ) {
    HRESULT _hr = raw_Pause();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMSMQOutgoingQueueManagement::EodResend ( ) {
    HRESULT _hr = raw_EodResend();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IMSMQQueueManagement wrapper method implementations
//

inline long IMSMQQueueManagement::GetJournalMessageCount ( ) {
    long _result;
    HRESULT _hr = get_JournalMessageCount(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _variant_t IMSMQQueueManagement::GetBytesInJournal ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_BytesInJournal(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _variant_t IMSMQQueueManagement::EodGetReceiveInfo ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_EodGetReceiveInfo(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}