JMAIL.rar jmail.tli

www.pudn.com > JMAIL.rar > jmail.tli

// Created by Microsoft (R) C/C++ Compiler Version 12.00.8168.0 (5df1f9bc).
//
// jmail.tli
//
// Wrapper implementations for Win32 type library ..\jmail.dll
// compiler-generated file created 01/10/08 at 13:11:07 - DO NOT EDIT!

#pragma once

//
// interface IPOP3 wrapper method implementations
//

inline HRESULT IPOP3::Connect ( _bstr_t Username, _bstr_t Password, _bstr_t Server, long Port ) {
HRESULT _hr = raw_Connect(Username, Password, Server, Port);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

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

inline _bstr_t IPOP3::GetLog ( ) {
BSTR _result;
HRESULT _hr = get_Log(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL IPOP3::GetLogging ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Logging(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IPOP3::PutLogging ( VARIANT_BOOL Log ) {
HRESULT _hr = put_Logging(Log);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

inline long IPOP3::GetSize ( ) {
long _result;
HRESULT _hr = get_Size(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline IMessagesPtr IPOP3::GetMessages ( ) {
struct IMessages * _result;
HRESULT _hr = get_Messages(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagesPtr(_result, false);
}

inline long IPOP3::GetLastUnreadMessage ( ) {
long _result;
HRESULT _hr = raw_GetLastUnreadMessage(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline HRESULT IPOP3::DownloadSingleHeader ( long MessageID ) {
HRESULT _hr = raw_DownloadSingleHeader(MessageID);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IPOP3::DeleteSingleMessage ( long MessageID ) {
HRESULT _hr = raw_DeleteSingleMessage(MessageID);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IPOP3::DownloadHeaders ( ) {
HRESULT _hr = raw_DownloadHeaders();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IPOP3::DownloadMessages ( ) {
HRESULT _hr = raw_DownloadMessages();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IPOP3::GetMessageUID ( long MessageID ) {
BSTR _result;
HRESULT _hr = raw_GetMessageUID(MessageID, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IPOP3::DeleteMessages ( ) {
HRESULT _hr = raw_DeleteMessages();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IPOP3::DownloadUnreadMessages ( ) {
HRESULT _hr = raw_DownloadUnreadMessages();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IMessagePtr IPOP3::DownloadSingleMessage ( long index ) {
struct IMessage * _result;
HRESULT _hr = raw_DownloadSingleMessage(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline long IPOP3::GetTimeout ( ) {
long _result;
HRESULT _hr = get_Timeout(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IPOP3::PutTimeout ( long Value ) {
HRESULT _hr = put_Timeout(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IMessages wrapper method implementations
//

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

inline HRESULT IMessages::Clear ( ) {
HRESULT _hr = raw_Clear();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IMessagePtr IMessages::GetItem ( long index ) {
struct IMessage * _result;
HRESULT _hr = get_Item(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline void IMessages::PutItem ( long index, struct IMessage * Value ) {
HRESULT _hr = put_Item(index, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IMessage wrapper method implementations
//

inline DATE IMessage::GetDate ( ) {
DATE _result;
HRESULT _hr = get_Date(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline long IMessage::GetSize ( ) {
long _result;
HRESULT _hr = get_Size(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline HRESULT IMessage::LoadFromStream ( IUnknown * Stream ) {
HRESULT _hr = raw_LoadFromStream(Stream);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::SaveToStream ( IUnknown * Stream ) {
HRESULT _hr = raw_SaveToStream(Stream);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::ParseMessage ( _bstr_t MessageSource ) {
HRESULT _hr = raw_ParseMessage(MessageSource);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::GetText ( ) {
BSTR _result;
HRESULT _hr = get_Text(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline IHeadersPtr IMessage::GetHeaders ( ) {
struct IHeaders * _result;
HRESULT _hr = get_Headers(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IHeadersPtr(_result, false);
}

inline IRecipientsPtr IMessage::GetRecipients ( ) {
struct IRecipients * _result;
HRESULT _hr = get_Recipients(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IRecipientsPtr(_result, false);
}

inline IAttachmentsPtr IMessage::GetAttachments ( ) {
struct IAttachments * _result;
HRESULT _hr = get_Attachments(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IAttachmentsPtr(_result, false);
}

inline _bstr_t IMessage::GetSubject ( ) {
BSTR _result;
HRESULT _hr = get_Subject(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutSubject ( _bstr_t Value ) {
HRESULT _hr = put_Subject(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetFrom ( ) {
BSTR _result;
HRESULT _hr = get_From(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutFrom ( _bstr_t Value ) {
HRESULT _hr = put_From(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetFromName ( ) {
BSTR _result;
HRESULT _hr = get_FromName(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutFromName ( _bstr_t Value ) {
HRESULT _hr = put_FromName(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetBody ( ) {
BSTR _result;
HRESULT _hr = get_Body(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutBody ( _bstr_t Value ) {
HRESULT _hr = put_Body(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline unsigned char IMessage::GetPriority ( ) {
unsigned char _result;
HRESULT _hr = get_Priority(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutPriority ( unsigned char Value ) {
HRESULT _hr = put_Priority(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetContentType ( ) {
BSTR _result;
HRESULT _hr = get_ContentType(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutContentType ( _bstr_t Value ) {
HRESULT _hr = put_ContentType(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMessage::Send ( _bstr_t mailServer, VARIANT_BOOL enque ) {
VARIANT_BOOL _result;
HRESULT _hr = raw_Send(mailServer, enque, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline _bstr_t IMessage::GetBodyText ( ) {
BSTR _result;
HRESULT _hr = get_BodyText(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IMessage::DecodeHeader ( _bstr_t Header ) {
BSTR _result;
HRESULT _hr = raw_DecodeHeader(Header, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IMessage::SendToNewsGroup ( _bstr_t ServerName, _bstr_t Newsgroups ) {
HRESULT _hr = raw_SendToNewsGroup(ServerName, Newsgroups);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IUnknownPtr IMessage::GetEnvelope ( ) {
IUnknown * _result;
HRESULT _hr = get_Envelope(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IUnknownPtr(_result, false);
}

inline void IMessage::PutEnvelope ( IUnknown * Value ) {
HRESULT _hr = put_Envelope(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMsPickupdirectory ( ) {
BSTR _result;
HRESULT _hr = get_MsPickupdirectory(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutMsPickupdirectory ( _bstr_t Value ) {
HRESULT _hr = put_MsPickupdirectory(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMessage::nq ( ) {
HRESULT _hr = raw_nq();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IPGPKeysPtr IMessage::KeyInformation ( _bstr_t keyIdentifier ) {
struct IPGPKeys * _result;
HRESULT _hr = raw_KeyInformation(keyIdentifier, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPKeysPtr(_result, false);
}

inline VARIANT_BOOL IMessage::GetPGPEncrypt ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_PGPEncrypt(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutPGPEncrypt ( VARIANT_BOOL Value ) {
HRESULT _hr = put_PGPEncrypt(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMessage::GetPGPSign ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_PGPSign(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutPGPSign ( VARIANT_BOOL Value ) {
HRESULT _hr = put_PGPSign(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetPGPPassphrase ( ) {
BSTR _result;
HRESULT _hr = get_PGPPassphrase(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutPGPPassphrase ( _bstr_t passPhrase ) {
HRESULT _hr = put_PGPPassphrase(passPhrase);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetPGPSignkey ( ) {
BSTR _result;
HRESULT _hr = get_PGPSignkey(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutPGPSignkey ( _bstr_t signKey ) {
HRESULT _hr = put_PGPSignkey(signKey);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetReplyTo ( ) {
BSTR _result;
HRESULT _hr = get_ReplyTo(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutReplyTo ( _bstr_t Value ) {
HRESULT _hr = put_ReplyTo(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetHideRecipients ( ) {
BSTR _result;
HRESULT _hr = get_HideRecipients(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutHideRecipients ( _bstr_t Value ) {
HRESULT _hr = put_HideRecipients(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMailDomain ( ) {
BSTR _result;
HRESULT _hr = get_MailDomain(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutMailDomain ( _bstr_t Value ) {
HRESULT _hr = put_MailDomain(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetCharset ( ) {
BSTR _result;
HRESULT _hr = get_Charset(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutCharset ( _bstr_t Value ) {
HRESULT _hr = put_Charset(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetContentTransferEncoding ( ) {
BSTR _result;
HRESULT _hr = get_ContentTransferEncoding(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutContentTransferEncoding ( _bstr_t Value ) {
HRESULT _hr = put_ContentTransferEncoding(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMimeVersion ( ) {
BSTR _result;
HRESULT _hr = get_MimeVersion(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutMimeVersion ( _bstr_t Value ) {
HRESULT _hr = put_MimeVersion(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetEncoding ( ) {
BSTR _result;
HRESULT _hr = get_Encoding(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutEncoding ( _bstr_t Value ) {
HRESULT _hr = put_Encoding(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMessage::GetReturnReceipt ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_ReturnReceipt(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutReturnReceipt ( VARIANT_BOOL Value ) {
HRESULT _hr = put_ReturnReceipt(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMessage::LogCustomMessage ( _bstr_t Message ) {
HRESULT _hr = raw_LogCustomMessage(Message);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::GetLog ( ) {
BSTR _result;
HRESULT _hr = get_Log(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL IMessage::GetLogging ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Logging(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutLogging ( VARIANT_BOOL Value ) {
HRESULT _hr = put_Logging(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetHTMLBody ( ) {
BSTR _result;
HRESULT _hr = get_HTMLBody(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutHTMLBody ( _bstr_t Value ) {
HRESULT _hr = put_HTMLBody(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

inline VARIANT_BOOL IMessage::GetISOEncodeHeaders ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_ISOEncodeHeaders(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutISOEncodeHeaders ( VARIANT_BOOL Value ) {
HRESULT _hr = put_ISOEncodeHeaders(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMessage::ClearCustomHeaders ( ) {
HRESULT _hr = raw_ClearCustomHeaders();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline VARIANT_BOOL IMessage::GetUsePipelining ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_UsePipelining(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutUsePipelining ( VARIANT_BOOL Value ) {
HRESULT _hr = put_UsePipelining(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMessage::GetSilent ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Silent(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutSilent ( VARIANT_BOOL Value ) {
HRESULT _hr = put_Silent(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IMessage::GetErrorCode ( ) {
long _result;
HRESULT _hr = get_ErrorCode(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline _bstr_t IMessage::GetErrorMessage ( ) {
BSTR _result;
HRESULT _hr = get_ErrorMessage(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IMessage::GetErrorSource ( ) {
BSTR _result;
HRESULT _hr = get_ErrorSource(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL IMessage::GetSimpleLayout ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_SimpleLayout(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutSimpleLayout ( VARIANT_BOOL Value ) {
HRESULT _hr = put_SimpleLayout(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMessage::GetMessageBodyFromURL ( _bstr_t bstrURL, _bstr_t bstrAuth ) {
HRESULT _hr = raw_GetMessageBodyFromURL(bstrURL, bstrAuth);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::AddURLAttachment ( _bstr_t bstrURL, _bstr_t bstrAttachAs, VARIANT_BOOL isInline, _bstr_t bstrAuth ) {
BSTR _result;
HRESULT _hr = raw_AddURLAttachment(bstrURL, bstrAttachAs, isInline, bstrAuth, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IMessage::ExtractEmailAddressesFromURL ( _bstr_t bstrURL, _bstr_t bstrAuth ) {
HRESULT _hr = raw_ExtractEmailAddressesFromURL(bstrURL, bstrAuth);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::GetRecipientsString ( ) {
BSTR _result;
HRESULT _hr = get_RecipientsString(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline DATE IMessage::GetDeferredDelivery ( ) {
DATE _result;
HRESULT _hr = get_DeferredDelivery(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutDeferredDelivery ( DATE Value ) {
HRESULT _hr = put_DeferredDelivery(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMailData ( ) {
BSTR _result;
HRESULT _hr = get_MailData(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IMessage::GetAbout ( ) {
BSTR _result;
HRESULT _hr = get_About(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IMessage::AddRecipient ( _bstr_t emailAddress, _bstr_t recipientName, _bstr_t PGPKey ) {
HRESULT _hr = raw_AddRecipient(emailAddress, recipientName, PGPKey);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AddRecipientCC ( _bstr_t emailAddress, _bstr_t recipientName, _bstr_t PGPKey ) {
HRESULT _hr = raw_AddRecipientCC(emailAddress, recipientName, PGPKey);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AddRecipientBCC ( _bstr_t emailAddress, _bstr_t PGPKey ) {
HRESULT _hr = raw_AddRecipientBCC(emailAddress, PGPKey);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::GetVersion ( ) {
BSTR _result;
HRESULT _hr = get_Version(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL IMessage::VerifyKeys ( _bstr_t keyString ) {
VARIANT_BOOL _result;
HRESULT _hr = raw_VerifyKeys(keyString, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline HRESULT IMessage::ClearRecipients ( ) {
HRESULT _hr = raw_ClearRecipients();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::ClearAttachments ( ) {
HRESULT _hr = raw_ClearAttachments();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AppendBodyFromFile ( _bstr_t FileName ) {
HRESULT _hr = raw_AppendBodyFromFile(FileName);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AppendText ( _bstr_t Text ) {
HRESULT _hr = raw_AppendText(Text);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMessage::AddAttachment ( _bstr_t FileName, VARIANT_BOOL isInline, _bstr_t ContentType ) {
BSTR _result;
HRESULT _hr = raw_AddAttachment(FileName, isInline, ContentType, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IMessage::AddCustomAttachment ( _bstr_t FileName, _bstr_t Data, VARIANT_BOOL isInline ) {
BSTR _result;
HRESULT _hr = raw_AddCustomAttachment(FileName, Data, isInline, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IMessage::AddHeader ( _bstr_t XHeader, _bstr_t Value ) {
HRESULT _hr = raw_AddHeader(XHeader, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AddNativeHeader ( _bstr_t Header, _bstr_t Value ) {
HRESULT _hr = raw_AddNativeHeader(Header, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline VARIANT_BOOL IMessage::GetEncryptAttachments ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_EncryptAttachments(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutEncryptAttachments ( VARIANT_BOOL Value ) {
HRESULT _hr = put_EncryptAttachments(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMailServerUserName ( ) {
BSTR _result;
HRESULT _hr = get_MailServerUserName(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutMailServerUserName ( _bstr_t Value ) {
HRESULT _hr = put_MailServerUserName(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMessage::GetMailServerPassWord ( ) {
BSTR _result;
HRESULT _hr = get_MailServerPassWord(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMessage::PutMailServerPassWord ( _bstr_t Value ) {
HRESULT _hr = put_MailServerPassWord(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMessage::Clear ( ) {
HRESULT _hr = raw_Clear();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IMessage::AppendHTML ( _bstr_t Text ) {
HRESULT _hr = raw_AppendHTML(Text);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IPGPDecodeResultsPtr IMessage::PGPDecode ( VARIANT_BOOL DecodeBody, VARIANT_BOOL DecodeAttachments ) {
struct IPGPDecodeResults * _result;
HRESULT _hr = raw_PGPDecode(DecodeBody, DecodeAttachments, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPDecodeResultsPtr(_result, false);
}

inline VARIANT_BOOL IMessage::GetEnableCharsetTranslation ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_EnableCharsetTranslation(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMessage::PutEnableCharsetTranslation ( VARIANT_BOOL Value ) {
HRESULT _hr = put_EnableCharsetTranslation(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IHeaders wrapper method implementations
//

inline _bstr_t IHeaders::GetHeader ( _bstr_t Headername ) {
BSTR _result;
HRESULT _hr = raw_GetHeader(Headername, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IHeaders::GetText ( ) {
BSTR _result;
HRESULT _hr = get_Text(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

//
// interface IRecipients wrapper method implementations
//

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

inline IRecipientPtr IRecipients::GetItem ( long index ) {
struct IRecipient * _result;
HRESULT _hr = get_Item(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IRecipientPtr(_result, false);
}

inline HRESULT IRecipients::Add ( struct IRecipient * Value ) {
HRESULT _hr = raw_Add(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT IRecipients::Clear ( ) {
HRESULT _hr = raw_Clear();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

//
// interface IRecipient wrapper method implementations
//

inline _bstr_t IRecipient::GetName ( ) {
BSTR _result;
HRESULT _hr = get_Name(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IRecipient::GetEMail ( ) {
BSTR _result;
HRESULT _hr = get_EMail(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline long IRecipient::GetReType ( ) {
long _result;
HRESULT _hr = get_ReType(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline IRecipientPtr IRecipient::New ( _bstr_t Name, _bstr_t EMail, char recipientType ) {
struct IRecipient * _result;
HRESULT _hr = raw_New(Name, EMail, recipientType, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IRecipientPtr(_result, false);
}

//
// interface IAttachments wrapper method implementations
//

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

inline HRESULT IAttachments::Add ( struct IAttachment * * Attachment ) {
HRESULT _hr = raw_Add(Attachment);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline IAttachmentPtr IAttachments::GetItem ( long index ) {
struct IAttachment * _result;
HRESULT _hr = get_Item(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IAttachmentPtr(_result, false);
}

inline HRESULT IAttachments::Clear ( ) {
HRESULT _hr = raw_Clear();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

//
// interface IAttachment wrapper method implementations
//

inline _bstr_t IAttachment::GetName ( ) {
BSTR _result;
HRESULT _hr = get_Name(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline long IAttachment::GetSize ( ) {
long _result;
HRESULT _hr = get_Size(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline _bstr_t IAttachment::GetContentType ( ) {
BSTR _result;
HRESULT _hr = get_ContentType(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT IAttachment::SaveToFile ( _bstr_t FileName ) {
HRESULT _hr = raw_SaveToFile(FileName);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IAttachment::GetData ( ) {
BSTR _result;
HRESULT _hr = get_Data(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IAttachment::PutData ( _bstr_t Value ) {
HRESULT _hr = put_Data(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IAttachmentPtr IAttachment::New ( _bstr_t FileName, _bstr_t ContentType, _bstr_t Data ) {
struct IAttachment * _result;
HRESULT _hr = raw_New(FileName, ContentType, Data, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IAttachmentPtr(_result, false);
}

inline VARIANT_BOOL IAttachment::GetisInline ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_isInline(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IAttachment::PutisInline ( VARIANT_BOOL Value ) {
HRESULT _hr = put_isInline(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IAttachment::GetBinaryData ( ) {
BSTR _result;
HRESULT _hr = get_BinaryData(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IAttachment::PutBinaryData ( _bstr_t Value ) {
HRESULT _hr = put_BinaryData(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface ISMTPMail wrapper method implementations
//

inline VARIANT_BOOL ISMTPMail::Execute ( ) {
VARIANT_BOOL _result;
HRESULT _hr = raw_Execute(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline HRESULT ISMTPMail::AppendBodyFromFile ( _bstr_t FileName ) {
HRESULT _hr = raw_AppendBodyFromFile(FileName);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::AppendText ( _bstr_t Text ) {
HRESULT _hr = raw_AppendText(Text);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t ISMTPMail::AddAttachment ( _bstr_t FileName, _bstr_t ContentType ) {
BSTR _result;
HRESULT _hr = raw_AddAttachment(FileName, ContentType, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t ISMTPMail::AddCustomAttachment ( _bstr_t FileName, _bstr_t Data ) {
BSTR _result;
HRESULT _hr = raw_AddCustomAttachment(FileName, Data, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT ISMTPMail::AddRecipient ( _bstr_t EMail ) {
HRESULT _hr = raw_AddRecipient(EMail);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::AddRecipientCC ( _bstr_t EMail ) {
HRESULT _hr = raw_AddRecipientCC(EMail);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::AddRecipientBCC ( _bstr_t EMail ) {
HRESULT _hr = raw_AddRecipientBCC(EMail);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::AddHeader ( _bstr_t XHeader, _bstr_t Value ) {
HRESULT _hr = raw_AddHeader(XHeader, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::AddNativeHeader ( _bstr_t Header, _bstr_t Value ) {
HRESULT _hr = raw_AddNativeHeader(Header, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::ClearRecipients ( ) {
HRESULT _hr = raw_ClearRecipients();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISMTPMail::ClearAttachments ( ) {
HRESULT _hr = raw_ClearAttachments();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t ISMTPMail::GetServerAddress ( ) {
BSTR _result;
HRESULT _hr = get_ServerAddress(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutServerAddress ( _bstr_t Value ) {
HRESULT _hr = put_ServerAddress(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long ISMTPMail::GetServerPort ( ) {
long _result;
HRESULT _hr = get_ServerPort(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutServerPort ( long Value ) {
HRESULT _hr = put_ServerPort(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetSender ( ) {
BSTR _result;
HRESULT _hr = get_Sender(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutSender ( _bstr_t Value ) {
HRESULT _hr = put_Sender(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetSenderName ( ) {
BSTR _result;
HRESULT _hr = get_SenderName(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutSenderName ( _bstr_t Value ) {
HRESULT _hr = put_SenderName(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetReplyTo ( ) {
BSTR _result;
HRESULT _hr = get_ReplyTo(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutReplyTo ( _bstr_t Value ) {
HRESULT _hr = put_ReplyTo(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetSubject ( ) {
BSTR _result;
HRESULT _hr = get_Subject(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutSubject ( _bstr_t Value ) {
HRESULT _hr = put_Subject(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetBody ( ) {
BSTR _result;
HRESULT _hr = get_Body(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutBody ( _bstr_t Value ) {
HRESULT _hr = put_Body(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetContentType ( ) {
BSTR _result;
HRESULT _hr = get_ContentType(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutContentType ( _bstr_t Value ) {
HRESULT _hr = put_ContentType(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

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

inline _bstr_t ISMTPMail::GetHideRecipients ( ) {
BSTR _result;
HRESULT _hr = get_HideRecipients(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutHideRecipients ( _bstr_t Value ) {
HRESULT _hr = put_HideRecipients(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetMailDomain ( ) {
BSTR _result;
HRESULT _hr = get_MailDomain(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutMailDomain ( _bstr_t Value ) {
HRESULT _hr = put_MailDomain(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ISMTPMail::GetLazysend ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Lazysend(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutLazysend ( VARIANT_BOOL Value ) {
HRESULT _hr = put_Lazysend(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetCharset ( ) {
BSTR _result;
HRESULT _hr = get_Charset(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutCharset ( _bstr_t Value ) {
HRESULT _hr = put_Charset(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetContentTransferEncoding ( ) {
BSTR _result;
HRESULT _hr = get_ContentTransferEncoding(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutContentTransferEncoding ( _bstr_t Value ) {
HRESULT _hr = put_ContentTransferEncoding(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetMimeVersion ( ) {
BSTR _result;
HRESULT _hr = get_MimeVersion(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutMimeVersion ( _bstr_t Value ) {
HRESULT _hr = put_MimeVersion(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetEncoding ( ) {
BSTR _result;
HRESULT _hr = get_Encoding(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutEncoding ( _bstr_t Value ) {
HRESULT _hr = put_Encoding(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ISMTPMail::AddRecipientEx ( _bstr_t EMail, _bstr_t Name ) {
HRESULT _hr = raw_AddRecipientEx(EMail, Name);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline VARIANT_BOOL ISMTPMail::GetReturnReceipt ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_ReturnReceipt(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutReturnReceipt ( VARIANT_BOOL Value ) {
HRESULT _hr = put_ReturnReceipt(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ISMTPMail::LogCustomMessage ( _bstr_t Message ) {
HRESULT _hr = raw_LogCustomMessage(Message);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t ISMTPMail::GetLog ( ) {
BSTR _result;
HRESULT _hr = get_Log(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL ISMTPMail::GetLogging ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Logging(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutLogging ( VARIANT_BOOL Value ) {
HRESULT _hr = put_Logging(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetHTMLBody ( ) {
BSTR _result;
HRESULT _hr = get_HTMLBody(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void ISMTPMail::PutHTMLBody ( _bstr_t Value ) {
HRESULT _hr = put_HTMLBody(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

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

inline VARIANT_BOOL ISMTPMail::GetISOEncodeHeaders ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_ISOEncodeHeaders(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutISOEncodeHeaders ( VARIANT_BOOL Value ) {
HRESULT _hr = put_ISOEncodeHeaders(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ISMTPMail::ClearCustomHeaders ( ) {
HRESULT _hr = raw_ClearCustomHeaders();
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline VARIANT_BOOL ISMTPMail::GetUsePipelining ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_UsePipelining(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutUsePipelining ( VARIANT_BOOL Value ) {
HRESULT _hr = put_UsePipelining(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL ISMTPMail::GetSilent ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Silent(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutSilent ( VARIANT_BOOL Value ) {
HRESULT _hr = put_Silent(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long ISMTPMail::GetErrorCode ( ) {
long _result;
HRESULT _hr = get_ErrorCode(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline _bstr_t ISMTPMail::GetErrorMessage ( ) {
BSTR _result;
HRESULT _hr = get_ErrorMessage(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t ISMTPMail::GetErrorSource ( ) {
BSTR _result;
HRESULT _hr = get_ErrorSource(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL ISMTPMail::GetSimpleLayout ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_SimpleLayout(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutSimpleLayout ( VARIANT_BOOL Value ) {
HRESULT _hr = put_SimpleLayout(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT ISMTPMail::GetMessageBodyFromURL ( _bstr_t bstrURL, _bstr_t bstrAuth ) {
HRESULT _hr = raw_GetMessageBodyFromURL(bstrURL, bstrAuth);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t ISMTPMail::AddURLAttachment ( _bstr_t bstrURL, _bstr_t bstrAttachAs, _bstr_t bstrAuth ) {
BSTR _result;
HRESULT _hr = raw_AddURLAttachment(bstrURL, bstrAttachAs, bstrAuth, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline HRESULT ISMTPMail::ExtractEmailAddressesFromURL ( _bstr_t bstrURL, _bstr_t bstrAuth ) {
HRESULT _hr = raw_ExtractEmailAddressesFromURL(bstrURL, bstrAuth);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t ISMTPMail::GetRecipients ( ) {
BSTR _result;
HRESULT _hr = get_Recipients(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline DATE ISMTPMail::GetDeferredDelivery ( ) {
DATE _result;
HRESULT _hr = get_DeferredDelivery(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void ISMTPMail::PutDeferredDelivery ( DATE Value ) {
HRESULT _hr = put_DeferredDelivery(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t ISMTPMail::GetVersion ( ) {
BSTR _result;
HRESULT _hr = get_Version(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline long ISMTPMail::GetMemCount ( ) {
long _result;
HRESULT _hr = get_MemCount(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline long ISMTPMail::GetMemSize ( ) {
long _result;
HRESULT _hr = get_MemSize(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline IMessagePtr ISMTPMail::GetMessage ( ) {
struct IMessage * _result;
HRESULT _hr = get_Message(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline void ISMTPMail::PutMessage ( struct IMessage * Value ) {
HRESULT _hr = put_Message(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IPGPKeys wrapper method implementations
//

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

inline IPGPKeyInfoPtr IPGPKeys::GetItem ( long index ) {
struct IPGPKeyInfo * _result;
HRESULT _hr = get_Item(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPKeyInfoPtr(_result, false);
}

inline HRESULT IPGPKeys::AddKey ( struct IPGPKeyInfo * key ) {
HRESULT _hr = raw_AddKey(key);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

//
// interface IPGPKeyInfo wrapper method implementations
//

inline _bstr_t IPGPKeyInfo::GetKeyUser ( ) {
BSTR _result;
HRESULT _hr = get_KeyUser(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IPGPKeyInfo::GetKeyID ( ) {
BSTR _result;
HRESULT _hr = get_KeyID(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline _bstr_t IPGPKeyInfo::GetKeyCreationDate ( ) {
BSTR _result;
HRESULT _hr = get_KeyCreationDate(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

//
// interface IMailMerge wrapper method implementations
//

inline VARIANT_BOOL IMailMerge::GetMergeAttachments ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_MergeAttachments(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline void IMailMerge::PutMergeAttachments ( VARIANT_BOOL Value ) {
HRESULT _hr = put_MergeAttachments(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMessagePtr IMailMerge::GetMailTemplate ( ) {
struct IMessage * _result;
HRESULT _hr = get_MailTemplate(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline void IMailMerge::PutMailTemplate ( struct IMessage * Value ) {
HRESULT _hr = put_MailTemplate(Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IMailMerge::SetDebugMode ( _bstr_t TestMailAddress, long TestCount ) {
HRESULT _hr = raw_SetDebugMode(TestMailAddress, TestCount);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline _bstr_t IMailMerge::GetItem ( _bstr_t VariableName ) {
BSTR _result;
HRESULT _hr = get_Item(VariableName, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline void IMailMerge::PutItem ( _bstr_t VariableName, _bstr_t Value ) {
HRESULT _hr = put_Item(VariableName, Value);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IMessagePtr IMailMerge::Expand ( ) {
struct IMessage * _result;
HRESULT _hr = raw_Expand(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline IMessagePtr IMailMerge::ExpandFromRecordSet ( const _variant_t &amt; RecordSet ) {
struct IMessage * _result;
HRESULT _hr = raw_ExpandFromRecordSet(RecordSet, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IMessagePtr(_result, false);
}

inline HRESULT IMailMerge::BulkMerge ( const _variant_t &amt; RecordSet, VARIANT_BOOL enque, _bstr_t Maildestination ) {
HRESULT _hr = raw_BulkMerge(RecordSet, enque, Maildestination);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

//
// interface ISpeedMailer wrapper method implementations
//

inline HRESULT ISpeedMailer::SendMail ( _bstr_t FromEMail, _bstr_t RecipientEMails, _bstr_t Subject, _bstr_t Body, _bstr_t MailServers ) {
HRESULT _hr = raw_SendMail(FromEMail, RecipientEMails, Subject, Body, MailServers);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISpeedMailer::EnqueMail ( _bstr_t FromEMail, _bstr_t RecipientEMails, _bstr_t Subject, _bstr_t Body, _bstr_t MsPickupdirectory ) {
HRESULT _hr = raw_EnqueMail(FromEMail, RecipientEMails, Subject, Body, MsPickupdirectory);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

inline HRESULT ISpeedMailer::SendXMLMail ( _bstr_t XML ) {
HRESULT _hr = raw_SendXMLMail(XML);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _hr;
}

//
// interface IPGPDecodeResult wrapper method implementations
//

inline VARIANT_BOOL IPGPDecodeResult::GetSigningUsed ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_SigningUsed(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline VARIANT_BOOL IPGPDecodeResult::GetSignatureGood ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_SignatureGood(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline VARIANT_BOOL IPGPDecodeResult::GetSuccess ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_Success(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline long IPGPDecodeResult::GetPGPErrorCode ( ) {
long _result;
HRESULT _hr = get_PGPErrorCode(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

inline _bstr_t IPGPDecodeResult::GetPGPErrorMsg ( ) {
BSTR _result;
HRESULT _hr = get_PGPErrorMsg(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _bstr_t(_result, false);
}

inline VARIANT_BOOL IPGPDecodeResult::GetEncryptionUsed ( ) {
VARIANT_BOOL _result;
HRESULT _hr = get_EncryptionUsed(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return _result;
}

//
// interface IPGPDecodeResults wrapper method implementations
//

inline IPGPDecodeResultPtr IPGPDecodeResults::GetBody ( ) {
struct IPGPDecodeResult * _result;
HRESULT _hr = get_Body(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPDecodeResultPtr(_result, false);
}

inline IPGPDecodeResultPtr IPGPDecodeResults::GetHTMLBody ( ) {
struct IPGPDecodeResult * _result;
HRESULT _hr = get_HTMLBody(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPDecodeResultPtr(_result, false);
}

inline IPGPDecodeResultCollectionPtr IPGPDecodeResults::GetAttachments ( ) {
struct IPGPDecodeResultCollection * _result;
HRESULT _hr = get_Attachments(&amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPDecodeResultCollectionPtr(_result, false);
}

//
// interface IPGPDecodeResultCollection wrapper method implementations
//

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

inline IPGPDecodeResultPtr IPGPDecodeResultCollection::GetItem ( long index ) {
struct IPGPDecodeResult * _result;
HRESULT _hr = get_Item(index, &amt;_result);
if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
return IPGPDecodeResultPtr(_result, false);
}