windows-server-2003/base/win32/fusion/inc/fusion_msxml3.tli

// Created by Microsoft (R) C/C++ Compiler Version 13.00.9176 (a63ade41).
//
// d:\fus6\base\win32\fusion\shims\obj\i386\msxml3.tli
//
// Wrapper implementations for Win32 type library msxml3.dll
// compiler-generated file created 08/08/01 at 15:10:30 - DO NOT EDIT!

#pragma once

//
// interface IXMLElementCollection wrapper method implementations
//

inline void IXMLElementCollection::Putlength ( long p ) {
    HRESULT _hr = put_length(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IXMLElementCollection::Getlength ( ) {
    long _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IUnknownPtr IXMLElementCollection::Get_newEnum ( ) {
    IUnknown * _result = 0;
    HRESULT _hr = get__newEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

inline IDispatchPtr IXMLElementCollection::item ( const _variant_t & var1, const _variant_t & var2 ) {
    IDispatch * _result = 0;
    HRESULT _hr = raw_item(var1, var2, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

//
// interface IXMLElement wrapper method implementations
//

inline _bstr_t IXMLElement::GettagName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_tagName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLElement::PuttagName ( _bstr_t p ) {
    HRESULT _hr = put_tagName(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLElementPtr IXMLElement::Getparent ( ) {
    struct IXMLElement * _result = 0;
    HRESULT _hr = get_parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementPtr(_result, false);
}

inline HRESULT IXMLElement::setAttribute ( _bstr_t strPropertyName, const _variant_t & PropertyValue ) {
    HRESULT _hr = raw_setAttribute(strPropertyName, PropertyValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _variant_t IXMLElement::getAttribute ( _bstr_t strPropertyName ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getAttribute(strPropertyName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT IXMLElement::removeAttribute ( _bstr_t strPropertyName ) {
    HRESULT _hr = raw_removeAttribute(strPropertyName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLElementCollectionPtr IXMLElement::Getchildren ( ) {
    struct IXMLElementCollection * _result = 0;
    HRESULT _hr = get_children(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementCollectionPtr(_result, false);
}

inline long IXMLElement::Gettype ( ) {
    long _result = 0;
    HRESULT _hr = get_type(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLElement::Gettext ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_text(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLElement::Puttext ( _bstr_t p ) {
    HRESULT _hr = put_text(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IXMLElement::addChild ( struct IXMLElement * pChildElem, long lIndex, long lReserved ) {
    HRESULT _hr = raw_addChild(pChildElem, lIndex, lReserved);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLElement::removeChild ( struct IXMLElement * pChildElem ) {
    HRESULT _hr = raw_removeChild(pChildElem);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IXMLDocument wrapper method implementations
//

inline IXMLElementPtr IXMLDocument::Getroot ( ) {
    struct IXMLElement * _result = 0;
    HRESULT _hr = get_root(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementPtr(_result, false);
}

inline _bstr_t IXMLDocument::GetfileSize ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileSize(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument::GetfileModifiedDate ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileModifiedDate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument::GetfileUpdatedDate ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileUpdatedDate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument::GetURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_URL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDocument::PutURL ( _bstr_t p ) {
    HRESULT _hr = put_URL(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IXMLDocument::GetmimeType ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_mimeType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline long IXMLDocument::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDocument::Getcharset ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_charset(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDocument::Putcharset ( _bstr_t p ) {
    HRESULT _hr = put_charset(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IXMLDocument::Getversion ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_version(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument::Getdoctype ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_doctype(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument::GetdtdURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_dtdURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline IXMLElementPtr IXMLDocument::createElement ( const _variant_t & vType, const _variant_t & var1 ) {
    struct IXMLElement * _result = 0;
    HRESULT _hr = raw_createElement(vType, var1, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementPtr(_result, false);
}

//
// interface IXMLElement2 wrapper method implementations
//

inline _bstr_t IXMLElement2::GettagName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_tagName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLElement2::PuttagName ( _bstr_t p ) {
    HRESULT _hr = put_tagName(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLElement2Ptr IXMLElement2::Getparent ( ) {
    struct IXMLElement2 * _result = 0;
    HRESULT _hr = get_parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElement2Ptr(_result, false);
}

inline HRESULT IXMLElement2::setAttribute ( _bstr_t strPropertyName, const _variant_t & PropertyValue ) {
    HRESULT _hr = raw_setAttribute(strPropertyName, PropertyValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _variant_t IXMLElement2::getAttribute ( _bstr_t strPropertyName ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getAttribute(strPropertyName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT IXMLElement2::removeAttribute ( _bstr_t strPropertyName ) {
    HRESULT _hr = raw_removeAttribute(strPropertyName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLElementCollectionPtr IXMLElement2::Getchildren ( ) {
    struct IXMLElementCollection * _result = 0;
    HRESULT _hr = get_children(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementCollectionPtr(_result, false);
}

inline long IXMLElement2::Gettype ( ) {
    long _result = 0;
    HRESULT _hr = get_type(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLElement2::Gettext ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_text(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLElement2::Puttext ( _bstr_t p ) {
    HRESULT _hr = put_text(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IXMLElement2::addChild ( struct IXMLElement2 * pChildElem, long lIndex, long lReserved ) {
    HRESULT _hr = raw_addChild(pChildElem, lIndex, lReserved);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLElement2::removeChild ( struct IXMLElement2 * pChildElem ) {
    HRESULT _hr = raw_removeChild(pChildElem);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLElementCollectionPtr IXMLElement2::Getattributes ( ) {
    struct IXMLElementCollection * _result = 0;
    HRESULT _hr = get_attributes(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElementCollectionPtr(_result, false);
}

//
// interface IXMLDocument2 wrapper method implementations
//

inline IXMLElement2Ptr IXMLDocument2::Getroot ( ) {
    struct IXMLElement2 * _result = 0;
    HRESULT _hr = get_root(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElement2Ptr(_result, false);
}

inline _bstr_t IXMLDocument2::GetfileSize ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileSize(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument2::GetfileModifiedDate ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileModifiedDate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument2::GetfileUpdatedDate ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_fileUpdatedDate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument2::GetURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_URL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDocument2::PutURL ( _bstr_t p ) {
    HRESULT _hr = put_URL(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IXMLDocument2::GetmimeType ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_mimeType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline long IXMLDocument2::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDocument2::Getcharset ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_charset(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDocument2::Putcharset ( _bstr_t p ) {
    HRESULT _hr = put_charset(p);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IXMLDocument2::Getversion ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_version(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument2::Getdoctype ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_doctype(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDocument2::GetdtdURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_dtdURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline IXMLElement2Ptr IXMLDocument2::createElement ( const _variant_t & vType, const _variant_t & var1 ) {
    struct IXMLElement2 * _result = 0;
    HRESULT _hr = raw_createElement(vType, var1, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLElement2Ptr(_result, false);
}

inline VARIANT_BOOL IXMLDocument2::Getasync ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_async(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLDocument2::Putasync ( VARIANT_BOOL pf ) {
    HRESULT _hr = put_async(pf);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IXMLAttribute wrapper method implementations
//

inline _bstr_t IXMLAttribute::Getname ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_name(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLAttribute::Getvalue ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_value(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IXMLError wrapper method implementations
//

inline HRESULT IXMLError::GetErrorInfo ( struct _xml_error * pErrorReturn ) {
    HRESULT _hr = raw_GetErrorInfo(pErrorReturn);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IXMLDOMImplementation wrapper method implementations
//

inline VARIANT_BOOL IXMLDOMImplementation::hasFeature ( _bstr_t feature, _bstr_t version ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_hasFeature(feature, version, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface IXMLDOMParseError wrapper method implementations
//

inline long IXMLDOMParseError::GeterrorCode ( ) {
    long _result = 0;
    HRESULT _hr = get_errorCode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDOMParseError::GetURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_URL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMParseError::Getreason ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_reason(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMParseError::GetsrcText ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_srcText(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline long IXMLDOMParseError::Getline ( ) {
    long _result = 0;
    HRESULT _hr = get_line(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXMLDOMParseError::Getlinepos ( ) {
    long _result = 0;
    HRESULT _hr = get_linepos(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXMLDOMParseError::Getfilepos ( ) {
    long _result = 0;
    HRESULT _hr = get_filepos(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ISAXEntityResolver wrapper method implementations
//

inline _variant_t ISAXEntityResolver::resolveEntity ( const wchar_t * pwchPublicId, const wchar_t * pwchSystemId ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_resolveEntity(pwchPublicId, pwchSystemId, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

//
// interface ISAXLocator wrapper method implementations
//

inline int ISAXLocator::getColumnNumber ( ) {
    int _result = 0;
    HRESULT _hr = raw_getColumnNumber(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ISAXLocator::getLineNumber ( ) {
    int _result = 0;
    HRESULT _hr = raw_getLineNumber(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline const wchar_t * ISAXLocator::getPublicId ( ) {
    const wchar_t * _result = 0;
    HRESULT _hr = raw_getPublicId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline const wchar_t * ISAXLocator::getSystemId ( ) {
    const wchar_t * _result = 0;
    HRESULT _hr = raw_getSystemId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface ISAXAttributes wrapper method implementations
//

inline int ISAXAttributes::getLength ( ) {
    int _result = 0;
    HRESULT _hr = raw_getLength(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ISAXAttributes::getURI ( int nIndex, const wchar_t * * ppwchUri, int * pcchUri ) {
    HRESULT _hr = raw_getURI(nIndex, ppwchUri, pcchUri);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getLocalName ( int nIndex, const wchar_t * * ppwchLocalName, int * pcchLocalName ) {
    HRESULT _hr = raw_getLocalName(nIndex, ppwchLocalName, pcchLocalName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getQName ( int nIndex, const wchar_t * * ppwchQName, int * pcchQName ) {
    HRESULT _hr = raw_getQName(nIndex, ppwchQName, pcchQName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getName ( int nIndex, const wchar_t * * ppwchUri, int * pcchUri, const wchar_t * * ppwchLocalName, int * pcchLocalName, const wchar_t * * ppwchQName, int * pcchQName ) {
    HRESULT _hr = raw_getName(nIndex, ppwchUri, pcchUri, ppwchLocalName, pcchLocalName, ppwchQName, pcchQName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline int ISAXAttributes::getIndexFromName ( const wchar_t * pwchUri, int cchUri, const wchar_t * pwchLocalName, int cchLocalName ) {
    int _result = 0;
    HRESULT _hr = raw_getIndexFromName(pwchUri, cchUri, pwchLocalName, cchLocalName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int ISAXAttributes::getIndexFromQName ( const wchar_t * pwchQName, int cchQName ) {
    int _result = 0;
    HRESULT _hr = raw_getIndexFromQName(pwchQName, cchQName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ISAXAttributes::getType ( int nIndex, const wchar_t * * ppwchType, int * pcchType ) {
    HRESULT _hr = raw_getType(nIndex, ppwchType, pcchType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getTypeFromName ( const wchar_t * pwchUri, int cchUri, const wchar_t * pwchLocalName, int cchLocalName, const wchar_t * * ppwchType, int * pcchType ) {
    HRESULT _hr = raw_getTypeFromName(pwchUri, cchUri, pwchLocalName, cchLocalName, ppwchType, pcchType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getTypeFromQName ( const wchar_t * pwchQName, int cchQName, const wchar_t * * ppwchType, int * pcchType ) {
    HRESULT _hr = raw_getTypeFromQName(pwchQName, cchQName, ppwchType, pcchType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getValue ( int nIndex, const wchar_t * * ppwchValue, int * pcchValue ) {
    HRESULT _hr = raw_getValue(nIndex, ppwchValue, pcchValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getValueFromName ( const wchar_t * pwchUri, int cchUri, const wchar_t * pwchLocalName, int cchLocalName, const wchar_t * * ppwchValue, int * pcchValue ) {
    HRESULT _hr = raw_getValueFromName(pwchUri, cchUri, pwchLocalName, cchLocalName, ppwchValue, pcchValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXAttributes::getValueFromQName ( const wchar_t * pwchQName, int cchQName, const wchar_t * * ppwchValue, int * pcchValue ) {
    HRESULT _hr = raw_getValueFromQName(pwchQName, cchQName, ppwchValue, pcchValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXContentHandler wrapper method implementations
//

inline HRESULT ISAXContentHandler::putDocumentLocator ( struct ISAXLocator * pLocator ) {
    HRESULT _hr = raw_putDocumentLocator(pLocator);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::startDocument ( ) {
    HRESULT _hr = raw_startDocument();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::endDocument ( ) {
    HRESULT _hr = raw_endDocument();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::startPrefixMapping ( const wchar_t * pwchPrefix, int cchPrefix, const wchar_t * pwchUri, int cchUri ) {
    HRESULT _hr = raw_startPrefixMapping(pwchPrefix, cchPrefix, pwchUri, cchUri);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::endPrefixMapping ( const wchar_t * pwchPrefix, int cchPrefix ) {
    HRESULT _hr = raw_endPrefixMapping(pwchPrefix, cchPrefix);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::startElement ( const wchar_t * pwchNamespaceUri, int cchNamespaceUri, const wchar_t * pwchLocalName, int cchLocalName, const wchar_t * pwchQName, int cchQName, struct ISAXAttributes * pAttributes ) {
    HRESULT _hr = raw_startElement(pwchNamespaceUri, cchNamespaceUri, pwchLocalName, cchLocalName, pwchQName, cchQName, pAttributes);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::endElement ( const wchar_t * pwchNamespaceUri, int cchNamespaceUri, const wchar_t * pwchLocalName, int cchLocalName, const wchar_t * pwchQName, int cchQName ) {
    HRESULT _hr = raw_endElement(pwchNamespaceUri, cchNamespaceUri, pwchLocalName, cchLocalName, pwchQName, cchQName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::characters ( const wchar_t * pwchChars, int cchChars ) {
    HRESULT _hr = raw_characters(pwchChars, cchChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::ignorableWhitespace ( const wchar_t * pwchChars, int cchChars ) {
    HRESULT _hr = raw_ignorableWhitespace(pwchChars, cchChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::processingInstruction ( const wchar_t * pwchTarget, int cchTarget, const wchar_t * pwchData, int cchData ) {
    HRESULT _hr = raw_processingInstruction(pwchTarget, cchTarget, pwchData, cchData);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXContentHandler::skippedEntity ( const wchar_t * pwchName, int cchName ) {
    HRESULT _hr = raw_skippedEntity(pwchName, cchName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXDTDHandler wrapper method implementations
//

inline HRESULT ISAXDTDHandler::notationDecl ( const wchar_t * pwchName, int cchName, const wchar_t * pwchPublicId, int cchPublicId, const wchar_t * pwchSystemId, int cchSystemId ) {
    HRESULT _hr = raw_notationDecl(pwchName, cchName, pwchPublicId, cchPublicId, pwchSystemId, cchSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXDTDHandler::unparsedEntityDecl ( const wchar_t * pwchName, int cchName, const wchar_t * pwchPublicId, int cchPublicId, const wchar_t * pwchSystemId, int cchSystemId, const wchar_t * pwchNotationName, int cchNotationName ) {
    HRESULT _hr = raw_unparsedEntityDecl(pwchName, cchName, pwchPublicId, cchPublicId, pwchSystemId, cchSystemId, pwchNotationName, cchNotationName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXErrorHandler wrapper method implementations
//

inline HRESULT ISAXErrorHandler::error ( struct ISAXLocator * pLocator, struct IErrorInfo * pErrorInfo, HRESULT hrErrorCode ) {
    HRESULT _hr = raw_error(pLocator, pErrorInfo, hrErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXErrorHandler::fatalError ( struct ISAXLocator * pLocator, struct IErrorInfo * pErrorInfo, HRESULT hrErrorCode ) {
    HRESULT _hr = raw_fatalError(pLocator, pErrorInfo, hrErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXErrorHandler::warning ( struct ISAXLocator * pLocator, struct IErrorInfo * pErrorInfo, HRESULT hrErrorCode ) {
    HRESULT _hr = raw_warning(pLocator, pErrorInfo, hrErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXXMLReader wrapper method implementations
//

inline VARIANT_BOOL ISAXXMLReader::getFeature ( const wchar_t * pwchName ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_getFeature(pwchName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ISAXXMLReader::putFeature ( const wchar_t * pwchName, VARIANT_BOOL vfValue ) {
    HRESULT _hr = raw_putFeature(pwchName, vfValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _variant_t ISAXXMLReader::getProperty ( const wchar_t * pwchName ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getProperty(pwchName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT ISAXXMLReader::putProperty ( const wchar_t * pwchName, const _variant_t & varValue ) {
    HRESULT _hr = raw_putProperty(pwchName, varValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ISAXEntityResolverPtr ISAXXMLReader::getEntityResolver ( ) {
    struct ISAXEntityResolver * _result = 0;
    HRESULT _hr = raw_getEntityResolver(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ISAXEntityResolverPtr(_result, false);
}

inline HRESULT ISAXXMLReader::putEntityResolver ( struct ISAXEntityResolver * pResolver ) {
    HRESULT _hr = raw_putEntityResolver(pResolver);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ISAXContentHandlerPtr ISAXXMLReader::getContentHandler ( ) {
    struct ISAXContentHandler * _result = 0;
    HRESULT _hr = raw_getContentHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ISAXContentHandlerPtr(_result, false);
}

inline HRESULT ISAXXMLReader::putContentHandler ( struct ISAXContentHandler * pHandler ) {
    HRESULT _hr = raw_putContentHandler(pHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ISAXDTDHandlerPtr ISAXXMLReader::getDTDHandler ( ) {
    struct ISAXDTDHandler * _result = 0;
    HRESULT _hr = raw_getDTDHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ISAXDTDHandlerPtr(_result, false);
}

inline HRESULT ISAXXMLReader::putDTDHandler ( struct ISAXDTDHandler * pHandler ) {
    HRESULT _hr = raw_putDTDHandler(pHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline ISAXErrorHandlerPtr ISAXXMLReader::getErrorHandler ( ) {
    struct ISAXErrorHandler * _result = 0;
    HRESULT _hr = raw_getErrorHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ISAXErrorHandlerPtr(_result, false);
}

inline HRESULT ISAXXMLReader::putErrorHandler ( struct ISAXErrorHandler * pHandler ) {
    HRESULT _hr = raw_putErrorHandler(pHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline const wchar_t * ISAXXMLReader::getBaseURL ( ) {
    const wchar_t * _result = 0;
    HRESULT _hr = raw_getBaseURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ISAXXMLReader::putBaseURL ( const wchar_t * pwchBaseUrl ) {
    HRESULT _hr = raw_putBaseURL(pwchBaseUrl);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline const wchar_t * ISAXXMLReader::getSecureBaseURL ( ) {
    const wchar_t * _result = 0;
    HRESULT _hr = raw_getSecureBaseURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT ISAXXMLReader::putSecureBaseURL ( const wchar_t * pwchSecureBaseUrl ) {
    HRESULT _hr = raw_putSecureBaseURL(pwchSecureBaseUrl);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXXMLReader::parse ( const _variant_t & varInput ) {
    HRESULT _hr = raw_parse(varInput);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXXMLReader::parseURL ( const wchar_t * pwchUrl ) {
    HRESULT _hr = raw_parseURL(pwchUrl);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXXMLFilter wrapper method implementations
//

inline ISAXXMLReaderPtr ISAXXMLFilter::getParent ( ) {
    struct ISAXXMLReader * _result = 0;
    HRESULT _hr = raw_getParent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ISAXXMLReaderPtr(_result, false);
}

inline HRESULT ISAXXMLFilter::putParent ( struct ISAXXMLReader * pReader ) {
    HRESULT _hr = raw_putParent(pReader);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXLexicalHandler wrapper method implementations
//

inline HRESULT ISAXLexicalHandler::startDTD ( const wchar_t * pwchName, int cchName, const wchar_t * pwchPublicId, int cchPublicId, const wchar_t * pwchSystemId, int cchSystemId ) {
    HRESULT _hr = raw_startDTD(pwchName, cchName, pwchPublicId, cchPublicId, pwchSystemId, cchSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::endDTD ( ) {
    HRESULT _hr = raw_endDTD();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::startEntity ( const wchar_t * pwchName, int cchName ) {
    HRESULT _hr = raw_startEntity(pwchName, cchName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::endEntity ( const wchar_t * pwchName, int cchName ) {
    HRESULT _hr = raw_endEntity(pwchName, cchName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::startCDATA ( ) {
    HRESULT _hr = raw_startCDATA();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::endCDATA ( ) {
    HRESULT _hr = raw_endCDATA();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXLexicalHandler::comment ( const wchar_t * pwchChars, int cchChars ) {
    HRESULT _hr = raw_comment(pwchChars, cchChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface ISAXDeclHandler wrapper method implementations
//

inline HRESULT ISAXDeclHandler::elementDecl ( const wchar_t * pwchName, int cchName, const wchar_t * pwchModel, int cchModel ) {
    HRESULT _hr = raw_elementDecl(pwchName, cchName, pwchModel, cchModel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXDeclHandler::attributeDecl ( const wchar_t * pwchElementName, int cchElementName, const wchar_t * pwchAttributeName, int cchAttributeName, const wchar_t * pwchType, int cchType, const wchar_t * pwchValueDefault, int cchValueDefault, const wchar_t * pwchValue, int cchValue ) {
    HRESULT _hr = raw_attributeDecl(pwchElementName, cchElementName, pwchAttributeName, cchAttributeName, pwchType, cchType, pwchValueDefault, cchValueDefault, pwchValue, cchValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXDeclHandler::internalEntityDecl ( const wchar_t * pwchName, int cchName, const wchar_t * pwchValue, int cchValue ) {
    HRESULT _hr = raw_internalEntityDecl(pwchName, cchName, pwchValue, cchValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT ISAXDeclHandler::externalEntityDecl ( const wchar_t * pwchName, int cchName, const wchar_t * pwchPublicId, int cchPublicId, const wchar_t * pwchSystemId, int cchSystemId ) {
    HRESULT _hr = raw_externalEntityDecl(pwchName, cchName, pwchPublicId, cchPublicId, pwchSystemId, cchSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXEntityResolver wrapper method implementations
//

inline _variant_t IVBSAXEntityResolver::resolveEntity ( BSTR * strPublicId, BSTR * strSystemId ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_resolveEntity(strPublicId, strSystemId, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

//
// interface IVBSAXLocator wrapper method implementations
//

inline int IVBSAXLocator::GetcolumnNumber ( ) {
    int _result = 0;
    HRESULT _hr = get_columnNumber(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int IVBSAXLocator::GetlineNumber ( ) {
    int _result = 0;
    HRESULT _hr = get_lineNumber(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IVBSAXLocator::GetpublicId ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_publicId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXLocator::GetsystemId ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_systemId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IVBSAXAttributes wrapper method implementations
//

inline int IVBSAXAttributes::Getlength ( ) {
    int _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IVBSAXAttributes::getURI ( int nIndex ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getURI(nIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getLocalName ( int nIndex ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getLocalName(nIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getQName ( int nIndex ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getQName(nIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline int IVBSAXAttributes::getIndexFromName ( _bstr_t strURI, _bstr_t strLocalName ) {
    int _result = 0;
    HRESULT _hr = raw_getIndexFromName(strURI, strLocalName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline int IVBSAXAttributes::getIndexFromQName ( _bstr_t strQName ) {
    int _result = 0;
    HRESULT _hr = raw_getIndexFromQName(strQName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IVBSAXAttributes::getType ( int nIndex ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getType(nIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getTypeFromName ( _bstr_t strURI, _bstr_t strLocalName ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getTypeFromName(strURI, strLocalName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getTypeFromQName ( _bstr_t strQName ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getTypeFromQName(strQName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getValue ( int nIndex ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getValue(nIndex, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getValueFromName ( _bstr_t strURI, _bstr_t strLocalName ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getValueFromName(strURI, strLocalName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IVBSAXAttributes::getValueFromQName ( _bstr_t strQName ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getValueFromQName(strQName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IVBSAXContentHandler wrapper method implementations
//

inline void IVBSAXContentHandler::PutRefdocumentLocator ( struct IVBSAXLocator * _arg1 ) {
    HRESULT _hr = putref_documentLocator(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IVBSAXContentHandler::startDocument ( ) {
    HRESULT _hr = raw_startDocument();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::endDocument ( ) {
    HRESULT _hr = raw_endDocument();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::startPrefixMapping ( BSTR * strPrefix, BSTR * strURI ) {
    HRESULT _hr = raw_startPrefixMapping(strPrefix, strURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::endPrefixMapping ( BSTR * strPrefix ) {
    HRESULT _hr = raw_endPrefixMapping(strPrefix);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::startElement ( BSTR * strNamespaceURI, BSTR * strLocalName, BSTR * strQName, struct IVBSAXAttributes * oAttributes ) {
    HRESULT _hr = raw_startElement(strNamespaceURI, strLocalName, strQName, oAttributes);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::endElement ( BSTR * strNamespaceURI, BSTR * strLocalName, BSTR * strQName ) {
    HRESULT _hr = raw_endElement(strNamespaceURI, strLocalName, strQName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::characters ( BSTR * strChars ) {
    HRESULT _hr = raw_characters(strChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::ignorableWhitespace ( BSTR * strChars ) {
    HRESULT _hr = raw_ignorableWhitespace(strChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::processingInstruction ( BSTR * strTarget, BSTR * strData ) {
    HRESULT _hr = raw_processingInstruction(strTarget, strData);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXContentHandler::skippedEntity ( BSTR * strName ) {
    HRESULT _hr = raw_skippedEntity(strName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXDTDHandler wrapper method implementations
//

inline HRESULT IVBSAXDTDHandler::notationDecl ( BSTR * strName, BSTR * strPublicId, BSTR * strSystemId ) {
    HRESULT _hr = raw_notationDecl(strName, strPublicId, strSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXDTDHandler::unparsedEntityDecl ( BSTR * strName, BSTR * strPublicId, BSTR * strSystemId, BSTR * strNotationName ) {
    HRESULT _hr = raw_unparsedEntityDecl(strName, strPublicId, strSystemId, strNotationName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXErrorHandler wrapper method implementations
//

inline HRESULT IVBSAXErrorHandler::error ( struct IVBSAXLocator * oLocator, BSTR * strError, long nErrorCode ) {
    HRESULT _hr = raw_error(oLocator, strError, nErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXErrorHandler::fatalError ( struct IVBSAXLocator * oLocator, BSTR * strError, long nErrorCode ) {
    HRESULT _hr = raw_fatalError(oLocator, strError, nErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXErrorHandler::warning ( struct IVBSAXLocator * oLocator, BSTR * strError, long nErrorCode ) {
    HRESULT _hr = raw_warning(oLocator, strError, nErrorCode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXXMLReader wrapper method implementations
//

inline VARIANT_BOOL IVBSAXXMLReader::getFeature ( _bstr_t strName ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_getFeature(strName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IVBSAXXMLReader::putFeature ( _bstr_t strName, VARIANT_BOOL fValue ) {
    HRESULT _hr = raw_putFeature(strName, fValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _variant_t IVBSAXXMLReader::getProperty ( _bstr_t strName ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getProperty(strName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT IVBSAXXMLReader::putProperty ( _bstr_t strName, const _variant_t & varValue ) {
    HRESULT _hr = raw_putProperty(strName, varValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IVBSAXEntityResolverPtr IVBSAXXMLReader::GetentityResolver ( ) {
    struct IVBSAXEntityResolver * _result = 0;
    HRESULT _hr = get_entityResolver(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IVBSAXEntityResolverPtr(_result, false);
}

inline void IVBSAXXMLReader::PutRefentityResolver ( struct IVBSAXEntityResolver * oResolver ) {
    HRESULT _hr = putref_entityResolver(oResolver);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IVBSAXContentHandlerPtr IVBSAXXMLReader::GetcontentHandler ( ) {
    struct IVBSAXContentHandler * _result = 0;
    HRESULT _hr = get_contentHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IVBSAXContentHandlerPtr(_result, false);
}

inline void IVBSAXXMLReader::PutRefcontentHandler ( struct IVBSAXContentHandler * oHandler ) {
    HRESULT _hr = putref_contentHandler(oHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IVBSAXDTDHandlerPtr IVBSAXXMLReader::GetdtdHandler ( ) {
    struct IVBSAXDTDHandler * _result = 0;
    HRESULT _hr = get_dtdHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IVBSAXDTDHandlerPtr(_result, false);
}

inline void IVBSAXXMLReader::PutRefdtdHandler ( struct IVBSAXDTDHandler * oHandler ) {
    HRESULT _hr = putref_dtdHandler(oHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IVBSAXErrorHandlerPtr IVBSAXXMLReader::GeterrorHandler ( ) {
    struct IVBSAXErrorHandler * _result = 0;
    HRESULT _hr = get_errorHandler(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IVBSAXErrorHandlerPtr(_result, false);
}

inline void IVBSAXXMLReader::PutReferrorHandler ( struct IVBSAXErrorHandler * oHandler ) {
    HRESULT _hr = putref_errorHandler(oHandler);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IVBSAXXMLReader::GetbaseURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_baseURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IVBSAXXMLReader::PutbaseURL ( _bstr_t strBaseURL ) {
    HRESULT _hr = put_baseURL(strBaseURL);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IVBSAXXMLReader::GetsecureBaseURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_secureBaseURL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IVBSAXXMLReader::PutsecureBaseURL ( _bstr_t strSecureBaseURL ) {
    HRESULT _hr = put_secureBaseURL(strSecureBaseURL);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IVBSAXXMLReader::parse ( const _variant_t & varInput ) {
    HRESULT _hr = raw_parse(varInput);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXXMLReader::parseURL ( _bstr_t strURL ) {
    HRESULT _hr = raw_parseURL(strURL);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXXMLFilter wrapper method implementations
//

inline IVBSAXXMLReaderPtr IVBSAXXMLFilter::Getparent ( ) {
    struct IVBSAXXMLReader * _result = 0;
    HRESULT _hr = get_parent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IVBSAXXMLReaderPtr(_result, false);
}

inline void IVBSAXXMLFilter::PutRefparent ( struct IVBSAXXMLReader * oReader ) {
    HRESULT _hr = putref_parent(oReader);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IVBSAXLexicalHandler wrapper method implementations
//

inline HRESULT IVBSAXLexicalHandler::startDTD ( BSTR * strName, BSTR * strPublicId, BSTR * strSystemId ) {
    HRESULT _hr = raw_startDTD(strName, strPublicId, strSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::endDTD ( ) {
    HRESULT _hr = raw_endDTD();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::startEntity ( BSTR * strName ) {
    HRESULT _hr = raw_startEntity(strName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::endEntity ( BSTR * strName ) {
    HRESULT _hr = raw_endEntity(strName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::startCDATA ( ) {
    HRESULT _hr = raw_startCDATA();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::endCDATA ( ) {
    HRESULT _hr = raw_endCDATA();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXLexicalHandler::comment ( BSTR * strChars ) {
    HRESULT _hr = raw_comment(strChars);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IVBSAXDeclHandler wrapper method implementations
//

inline HRESULT IVBSAXDeclHandler::elementDecl ( BSTR * strName, BSTR * strModel ) {
    HRESULT _hr = raw_elementDecl(strName, strModel);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXDeclHandler::attributeDecl ( BSTR * strElementName, BSTR * strAttributeName, BSTR * strType, BSTR * strValueDefault, BSTR * strValue ) {
    HRESULT _hr = raw_attributeDecl(strElementName, strAttributeName, strType, strValueDefault, strValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXDeclHandler::internalEntityDecl ( BSTR * strName, BSTR * strValue ) {
    HRESULT _hr = raw_internalEntityDecl(strName, strValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IVBSAXDeclHandler::externalEntityDecl ( BSTR * strName, BSTR * strPublicId, BSTR * strSystemId ) {
    HRESULT _hr = raw_externalEntityDecl(strName, strPublicId, strSystemId);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IMXWriter wrapper method implementations
//

inline void IMXWriter::Putoutput ( const _variant_t & varDestination ) {
    HRESULT _hr = put_output(varDestination);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IMXWriter::Getoutput ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_output(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IMXWriter::Putencoding ( _bstr_t strEncoding ) {
    HRESULT _hr = put_encoding(strEncoding);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMXWriter::Getencoding ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_encoding(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IMXWriter::PutbyteOrderMark ( VARIANT_BOOL fWriteByteOrderMark ) {
    HRESULT _hr = put_byteOrderMark(fWriteByteOrderMark);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMXWriter::GetbyteOrderMark ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_byteOrderMark(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMXWriter::Putindent ( VARIANT_BOOL fIndentMode ) {
    HRESULT _hr = put_indent(fIndentMode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMXWriter::Getindent ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_indent(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMXWriter::Putstandalone ( VARIANT_BOOL fValue ) {
    HRESULT _hr = put_standalone(fValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMXWriter::Getstandalone ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_standalone(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMXWriter::PutomitXMLDeclaration ( VARIANT_BOOL fValue ) {
    HRESULT _hr = put_omitXMLDeclaration(fValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMXWriter::GetomitXMLDeclaration ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_omitXMLDeclaration(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IMXWriter::Putversion ( _bstr_t strVersion ) {
    HRESULT _hr = put_version(strVersion);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IMXWriter::Getversion ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_version(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IMXWriter::PutdisableOutputEscaping ( VARIANT_BOOL fValue ) {
    HRESULT _hr = put_disableOutputEscaping(fValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IMXWriter::GetdisableOutputEscaping ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_disableOutputEscaping(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IMXWriter::flush ( ) {
    HRESULT _hr = raw_flush();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXWriter::reset ( ) {
    HRESULT _hr = raw_reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IMXAttributes wrapper method implementations
//

inline HRESULT IMXAttributes::addAttribute ( _bstr_t strURI, _bstr_t strLocalName, _bstr_t strQName, _bstr_t strType, _bstr_t strValue ) {
    HRESULT _hr = raw_addAttribute(strURI, strLocalName, strQName, strType, strValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::addAttributeFromIndex ( const _variant_t & varAtts, int nIndex ) {
    HRESULT _hr = raw_addAttributeFromIndex(varAtts, nIndex);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::clear ( ) {
    HRESULT _hr = raw_clear();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::removeAttribute ( int nIndex ) {
    HRESULT _hr = raw_removeAttribute(nIndex);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setAttribute ( int nIndex, _bstr_t strURI, _bstr_t strLocalName, _bstr_t strQName, _bstr_t strType, _bstr_t strValue ) {
    HRESULT _hr = raw_setAttribute(nIndex, strURI, strLocalName, strQName, strType, strValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setAttributes ( const _variant_t & varAtts ) {
    HRESULT _hr = raw_setAttributes(varAtts);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setLocalName ( int nIndex, _bstr_t strLocalName ) {
    HRESULT _hr = raw_setLocalName(nIndex, strLocalName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setQName ( int nIndex, _bstr_t strQName ) {
    HRESULT _hr = raw_setQName(nIndex, strQName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setType ( int nIndex, _bstr_t strType ) {
    HRESULT _hr = raw_setType(nIndex, strType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setURI ( int nIndex, _bstr_t strURI ) {
    HRESULT _hr = raw_setURI(nIndex, strURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXAttributes::setValue ( int nIndex, _bstr_t strValue ) {
    HRESULT _hr = raw_setValue(nIndex, strValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IMXReaderControl wrapper method implementations
//

inline HRESULT IMXReaderControl::abort ( ) {
    HRESULT _hr = raw_abort();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXReaderControl::resume ( ) {
    HRESULT _hr = raw_resume();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IMXReaderControl::suspend ( ) {
    HRESULT _hr = raw_suspend();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// dispinterface XMLDOMDocumentEvents wrapper method implementations
//

inline HRESULT XMLDOMDocumentEvents::ondataavailable ( ) {
    return _com_dispatch_method(this, 0xc6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

inline HRESULT XMLDOMDocumentEvents::onreadystatechange ( ) {
    return _com_dispatch_method(this, DISPID_READYSTATECHANGE, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

//
// interface IXMLHTTPRequest wrapper method implementations
//

inline HRESULT IXMLHTTPRequest::open ( _bstr_t bstrMethod, _bstr_t bstrUrl, const _variant_t & varAsync, const _variant_t & bstrUser, const _variant_t & bstrPassword ) {
    HRESULT _hr = raw_open(bstrMethod, bstrUrl, varAsync, bstrUser, bstrPassword);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLHTTPRequest::setRequestHeader ( _bstr_t bstrHeader, _bstr_t bstrValue ) {
    HRESULT _hr = raw_setRequestHeader(bstrHeader, bstrValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _bstr_t IXMLHTTPRequest::getResponseHeader ( _bstr_t bstrHeader ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getResponseHeader(bstrHeader, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLHTTPRequest::getAllResponseHeaders ( ) {
    BSTR _result = 0;
    HRESULT _hr = raw_getAllResponseHeaders(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline HRESULT IXMLHTTPRequest::send ( const _variant_t & varBody ) {
    HRESULT _hr = raw_send(varBody);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLHTTPRequest::abort ( ) {
    HRESULT _hr = raw_abort();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline long IXMLHTTPRequest::Getstatus ( ) {
    long _result = 0;
    HRESULT _hr = get_status(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLHTTPRequest::GetstatusText ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_statusText(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline IDispatchPtr IXMLHTTPRequest::GetresponseXML ( ) {
    IDispatch * _result = 0;
    HRESULT _hr = get_responseXML(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

inline _bstr_t IXMLHTTPRequest::GetresponseText ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_responseText(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _variant_t IXMLHTTPRequest::GetresponseBody ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_responseBody(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _variant_t IXMLHTTPRequest::GetresponseStream ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_responseStream(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline long IXMLHTTPRequest::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLHTTPRequest::Putonreadystatechange ( IDispatch * _arg1 ) {
    HRESULT _hr = put_onreadystatechange(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IServerXMLHTTPRequest wrapper method implementations
//

inline HRESULT IServerXMLHTTPRequest::setTimeouts ( long resolveTimeout, long connectTimeout, long sendTimeout, long receiveTimeout ) {
    HRESULT _hr = raw_setTimeouts(resolveTimeout, connectTimeout, sendTimeout, receiveTimeout);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL IServerXMLHTTPRequest::waitForResponse ( const _variant_t & timeoutInSeconds ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_waitForResponse(timeoutInSeconds, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface IXMLDOMNode wrapper method implementations
//

inline _bstr_t IXMLDOMNode::GetnodeName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_nodeName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _variant_t IXMLDOMNode::GetnodeValue ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_nodeValue(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IXMLDOMNode::PutnodeValue ( const _variant_t & value ) {
    HRESULT _hr = put_nodeValue(value);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline DOMNodeType IXMLDOMNode::GetnodeType ( ) {
    DOMNodeType _result;
    HRESULT _hr = get_nodeType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMNodePtr IXMLDOMNode::GetparentNode ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_parentNode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodeListPtr IXMLDOMNode::GetchildNodes ( ) {
    struct IXMLDOMNodeList * _result = 0;
    HRESULT _hr = get_childNodes(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodeListPtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::GetfirstChild ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_firstChild(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::GetlastChild ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_lastChild(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::GetpreviousSibling ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_previousSibling(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::GetnextSibling ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_nextSibling(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNamedNodeMapPtr IXMLDOMNode::Getattributes ( ) {
    struct IXMLDOMNamedNodeMap * _result = 0;
    HRESULT _hr = get_attributes(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNamedNodeMapPtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::insertBefore ( struct IXMLDOMNode * newChild, const _variant_t & refChild ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_insertBefore(newChild, refChild, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::replaceChild ( struct IXMLDOMNode * newChild, struct IXMLDOMNode * oldChild ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_replaceChild(newChild, oldChild, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::removeChild ( struct IXMLDOMNode * childNode ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_removeChild(childNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::appendChild ( struct IXMLDOMNode * newChild ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_appendChild(newChild, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline VARIANT_BOOL IXMLDOMNode::hasChildNodes ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_hasChildNodes(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMDocumentPtr IXMLDOMNode::GetownerDocument ( ) {
    struct IXMLDOMDocument * _result = 0;
    HRESULT _hr = get_ownerDocument(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMDocumentPtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::cloneNode ( VARIANT_BOOL deep ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_cloneNode(deep, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline _bstr_t IXMLDOMNode::GetnodeTypeString ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_nodeTypeString(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMNode::Gettext ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_text(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDOMNode::Puttext ( _bstr_t text ) {
    HRESULT _hr = put_text(text);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IXMLDOMNode::Getspecified ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_specified(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMNodePtr IXMLDOMNode::Getdefinition ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_definition(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline _variant_t IXMLDOMNode::GetnodeTypedValue ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_nodeTypedValue(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IXMLDOMNode::PutnodeTypedValue ( const _variant_t & typedValue ) {
    HRESULT _hr = put_nodeTypedValue(typedValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IXMLDOMNode::GetdataType ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_dataType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IXMLDOMNode::PutdataType ( _bstr_t dataTypeName ) {
    HRESULT _hr = put_dataType(dataTypeName);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _bstr_t IXMLDOMNode::Getxml ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_xml(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMNode::transformNode ( struct IXMLDOMNode * stylesheet ) {
    BSTR _result = 0;
    HRESULT _hr = raw_transformNode(stylesheet, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline IXMLDOMNodeListPtr IXMLDOMNode::selectNodes ( _bstr_t queryString ) {
    struct IXMLDOMNodeList * _result = 0;
    HRESULT _hr = raw_selectNodes(queryString, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodeListPtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNode::selectSingleNode ( _bstr_t queryString ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_selectSingleNode(queryString, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline VARIANT_BOOL IXMLDOMNode::Getparsed ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_parsed(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDOMNode::GetnamespaceURI ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_namespaceURI(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMNode::Getprefix ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_prefix(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMNode::GetbaseName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_baseName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline HRESULT IXMLDOMNode::transformNodeToObject ( struct IXMLDOMNode * stylesheet, const _variant_t & outputObject ) {
    HRESULT _hr = raw_transformNodeToObject(stylesheet, outputObject);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IXMLDOMNodeList wrapper method implementations
//

inline IXMLDOMNodePtr IXMLDOMNodeList::Getitem ( long index ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline long IXMLDOMNodeList::Getlength ( ) {
    long _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMNodePtr IXMLDOMNodeList::nextNode ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_nextNode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline HRESULT IXMLDOMNodeList::reset ( ) {
    HRESULT _hr = raw_reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IUnknownPtr IXMLDOMNodeList::Get_newEnum ( ) {
    IUnknown * _result = 0;
    HRESULT _hr = get__newEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

//
// interface IXMLDOMNamedNodeMap wrapper method implementations
//

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::getNamedItem ( _bstr_t name ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_getNamedItem(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::setNamedItem ( struct IXMLDOMNode * newItem ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_setNamedItem(newItem, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::removeNamedItem ( _bstr_t name ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_removeNamedItem(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::Getitem ( long index ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_item(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline long IXMLDOMNamedNodeMap::Getlength ( ) {
    long _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::getQualifiedItem ( _bstr_t baseName, _bstr_t namespaceURI ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_getQualifiedItem(baseName, namespaceURI, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::removeQualifiedItem ( _bstr_t baseName, _bstr_t namespaceURI ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_removeQualifiedItem(baseName, namespaceURI, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMNamedNodeMap::nextNode ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_nextNode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline HRESULT IXMLDOMNamedNodeMap::reset ( ) {
    HRESULT _hr = raw_reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IUnknownPtr IXMLDOMNamedNodeMap::Get_newEnum ( ) {
    IUnknown * _result = 0;
    HRESULT _hr = get__newEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

//
// interface IXMLDOMDocumentType wrapper method implementations
//

inline _bstr_t IXMLDOMDocumentType::Getname ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_name(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline IXMLDOMNamedNodeMapPtr IXMLDOMDocumentType::Getentities ( ) {
    struct IXMLDOMNamedNodeMap * _result = 0;
    HRESULT _hr = get_entities(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNamedNodeMapPtr(_result, false);
}

inline IXMLDOMNamedNodeMapPtr IXMLDOMDocumentType::Getnotations ( ) {
    struct IXMLDOMNamedNodeMap * _result = 0;
    HRESULT _hr = get_notations(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNamedNodeMapPtr(_result, false);
}

//
// interface IXMLDOMAttribute wrapper method implementations
//

inline _bstr_t IXMLDOMAttribute::Getname ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_name(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _variant_t IXMLDOMAttribute::Getvalue ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_value(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IXMLDOMAttribute::Putvalue ( const _variant_t & attributeValue ) {
    HRESULT _hr = put_value(attributeValue);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IXMLDOMElement wrapper method implementations
//

inline _bstr_t IXMLDOMElement::GettagName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_tagName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _variant_t IXMLDOMElement::getAttribute ( _bstr_t name ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getAttribute(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT IXMLDOMElement::setAttribute ( _bstr_t name, const _variant_t & value ) {
    HRESULT _hr = raw_setAttribute(name, value);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLDOMElement::removeAttribute ( _bstr_t name ) {
    HRESULT _hr = raw_removeAttribute(name);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLDOMAttributePtr IXMLDOMElement::getAttributeNode ( _bstr_t name ) {
    struct IXMLDOMAttribute * _result = 0;
    HRESULT _hr = raw_getAttributeNode(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMAttributePtr(_result, false);
}

inline IXMLDOMAttributePtr IXMLDOMElement::setAttributeNode ( struct IXMLDOMAttribute * DOMAttribute ) {
    struct IXMLDOMAttribute * _result = 0;
    HRESULT _hr = raw_setAttributeNode(DOMAttribute, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMAttributePtr(_result, false);
}

inline IXMLDOMAttributePtr IXMLDOMElement::removeAttributeNode ( struct IXMLDOMAttribute * DOMAttribute ) {
    struct IXMLDOMAttribute * _result = 0;
    HRESULT _hr = raw_removeAttributeNode(DOMAttribute, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMAttributePtr(_result, false);
}

inline IXMLDOMNodeListPtr IXMLDOMElement::getElementsByTagName ( _bstr_t tagName ) {
    struct IXMLDOMNodeList * _result = 0;
    HRESULT _hr = raw_getElementsByTagName(tagName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodeListPtr(_result, false);
}

inline HRESULT IXMLDOMElement::normalize ( ) {
    HRESULT _hr = raw_normalize();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IXMLDOMCharacterData wrapper method implementations
//

inline _bstr_t IXMLDOMCharacterData::Getdata ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_data(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDOMCharacterData::Putdata ( _bstr_t data ) {
    HRESULT _hr = put_data(data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IXMLDOMCharacterData::Getlength ( ) {
    long _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDOMCharacterData::substringData ( long offset, long count ) {
    BSTR _result = 0;
    HRESULT _hr = raw_substringData(offset, count, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline HRESULT IXMLDOMCharacterData::appendData ( _bstr_t data ) {
    HRESULT _hr = raw_appendData(data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLDOMCharacterData::insertData ( long offset, _bstr_t data ) {
    HRESULT _hr = raw_insertData(offset, data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLDOMCharacterData::deleteData ( long offset, long count ) {
    HRESULT _hr = raw_deleteData(offset, count);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXMLDOMCharacterData::replaceData ( long offset, long count, _bstr_t data ) {
    HRESULT _hr = raw_replaceData(offset, count, data);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IXMLDOMText wrapper method implementations
//

inline IXMLDOMTextPtr IXMLDOMText::splitText ( long offset ) {
    struct IXMLDOMText * _result = 0;
    HRESULT _hr = raw_splitText(offset, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMTextPtr(_result, false);
}

//
// interface IXMLDOMProcessingInstruction wrapper method implementations
//

inline _bstr_t IXMLDOMProcessingInstruction::Gettarget ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_target(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXMLDOMProcessingInstruction::Getdata ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_data(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDOMProcessingInstruction::Putdata ( _bstr_t value ) {
    HRESULT _hr = put_data(value);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IXMLDOMDocument wrapper method implementations
//

inline IXMLDOMDocumentTypePtr IXMLDOMDocument::Getdoctype ( ) {
    struct IXMLDOMDocumentType * _result = 0;
    HRESULT _hr = get_doctype(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMDocumentTypePtr(_result, false);
}

inline IXMLDOMImplementationPtr IXMLDOMDocument::Getimplementation ( ) {
    struct IXMLDOMImplementation * _result = 0;
    HRESULT _hr = get_implementation(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMImplementationPtr(_result, false);
}

inline IXMLDOMElementPtr IXMLDOMDocument::GetdocumentElement ( ) {
    struct IXMLDOMElement * _result = 0;
    HRESULT _hr = get_documentElement(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMElementPtr(_result, false);
}

inline void IXMLDOMDocument::PutRefdocumentElement ( struct IXMLDOMElement * DOMElement ) {
    HRESULT _hr = putref_documentElement(DOMElement);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLDOMElementPtr IXMLDOMDocument::createElement ( _bstr_t tagName ) {
    struct IXMLDOMElement * _result = 0;
    HRESULT _hr = raw_createElement(tagName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMElementPtr(_result, false);
}

inline IXMLDOMDocumentFragmentPtr IXMLDOMDocument::createDocumentFragment ( ) {
    struct IXMLDOMDocumentFragment * _result = 0;
    HRESULT _hr = raw_createDocumentFragment(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMDocumentFragmentPtr(_result, false);
}

inline IXMLDOMTextPtr IXMLDOMDocument::createTextNode ( _bstr_t data ) {
    struct IXMLDOMText * _result = 0;
    HRESULT _hr = raw_createTextNode(data, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMTextPtr(_result, false);
}

inline IXMLDOMCommentPtr IXMLDOMDocument::createComment ( _bstr_t data ) {
    struct IXMLDOMComment * _result = 0;
    HRESULT _hr = raw_createComment(data, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMCommentPtr(_result, false);
}

inline IXMLDOMCDATASectionPtr IXMLDOMDocument::createCDATASection ( _bstr_t data ) {
    struct IXMLDOMCDATASection * _result = 0;
    HRESULT _hr = raw_createCDATASection(data, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMCDATASectionPtr(_result, false);
}

inline IXMLDOMProcessingInstructionPtr IXMLDOMDocument::createProcessingInstruction ( _bstr_t target, _bstr_t data ) {
    struct IXMLDOMProcessingInstruction * _result = 0;
    HRESULT _hr = raw_createProcessingInstruction(target, data, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMProcessingInstructionPtr(_result, false);
}

inline IXMLDOMAttributePtr IXMLDOMDocument::createAttribute ( _bstr_t name ) {
    struct IXMLDOMAttribute * _result = 0;
    HRESULT _hr = raw_createAttribute(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMAttributePtr(_result, false);
}

inline IXMLDOMEntityReferencePtr IXMLDOMDocument::createEntityReference ( _bstr_t name ) {
    struct IXMLDOMEntityReference * _result = 0;
    HRESULT _hr = raw_createEntityReference(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMEntityReferencePtr(_result, false);
}

inline IXMLDOMNodeListPtr IXMLDOMDocument::getElementsByTagName ( _bstr_t tagName ) {
    struct IXMLDOMNodeList * _result = 0;
    HRESULT _hr = raw_getElementsByTagName(tagName, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodeListPtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMDocument::createNode ( const _variant_t & type, _bstr_t name, _bstr_t namespaceURI ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_createNode(type, name, namespaceURI, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMDocument::nodeFromID ( _bstr_t idString ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_nodeFromID(idString, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline VARIANT_BOOL IXMLDOMDocument::load ( const _variant_t & xmlSource ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_load(xmlSource, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXMLDOMDocument::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline IXMLDOMParseErrorPtr IXMLDOMDocument::GetparseError ( ) {
    struct IXMLDOMParseError * _result = 0;
    HRESULT _hr = get_parseError(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMParseErrorPtr(_result, false);
}

inline _bstr_t IXMLDOMDocument::GetURL ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_URL(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline VARIANT_BOOL IXMLDOMDocument::Getasync ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_async(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLDOMDocument::Putasync ( VARIANT_BOOL isAsync ) {
    HRESULT _hr = put_async(isAsync);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT IXMLDOMDocument::abort ( ) {
    HRESULT _hr = raw_abort();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL IXMLDOMDocument::loadXML ( _bstr_t bstrXML ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_loadXML(bstrXML, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IXMLDOMDocument::save ( const _variant_t & destination ) {
    HRESULT _hr = raw_save(destination);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline VARIANT_BOOL IXMLDOMDocument::GetvalidateOnParse ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_validateOnParse(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLDOMDocument::PutvalidateOnParse ( VARIANT_BOOL isValidating ) {
    HRESULT _hr = put_validateOnParse(isValidating);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IXMLDOMDocument::GetresolveExternals ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_resolveExternals(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLDOMDocument::PutresolveExternals ( VARIANT_BOOL isResolving ) {
    HRESULT _hr = put_resolveExternals(isResolving);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL IXMLDOMDocument::GetpreserveWhiteSpace ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = get_preserveWhiteSpace(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IXMLDOMDocument::PutpreserveWhiteSpace ( VARIANT_BOOL isPreserving ) {
    HRESULT _hr = put_preserveWhiteSpace(isPreserving);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline void IXMLDOMDocument::Putonreadystatechange ( const _variant_t & _arg1 ) {
    HRESULT _hr = put_onreadystatechange(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline void IXMLDOMDocument::Putondataavailable ( const _variant_t & _arg1 ) {
    HRESULT _hr = put_ondataavailable(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline void IXMLDOMDocument::Putontransformnode ( const _variant_t & _arg1 ) {
    HRESULT _hr = put_ontransformnode(_arg1);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

//
// interface IXMLDOMSchemaCollection wrapper method implementations
//

inline HRESULT IXMLDOMSchemaCollection::add ( _bstr_t namespaceURI, const _variant_t & var ) {
    HRESULT _hr = raw_add(namespaceURI, var);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLDOMNodePtr IXMLDOMSchemaCollection::get ( _bstr_t namespaceURI ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_get(namespaceURI, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline HRESULT IXMLDOMSchemaCollection::remove ( _bstr_t namespaceURI ) {
    HRESULT _hr = raw_remove(namespaceURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline long IXMLDOMSchemaCollection::Getlength ( ) {
    long _result = 0;
    HRESULT _hr = get_length(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXMLDOMSchemaCollection::GetnamespaceURI ( long index ) {
    BSTR _result = 0;
    HRESULT _hr = get_namespaceURI(index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline HRESULT IXMLDOMSchemaCollection::addCollection ( struct IXMLDOMSchemaCollection * otherCollection ) {
    HRESULT _hr = raw_addCollection(otherCollection);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IUnknownPtr IXMLDOMSchemaCollection::Get_newEnum ( ) {
    IUnknown * _result = 0;
    HRESULT _hr = get__newEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

//
// interface IXMLDOMDocument2 wrapper method implementations
//

inline IXMLDOMSchemaCollectionPtr IXMLDOMDocument2::Getnamespaces ( ) {
    struct IXMLDOMSchemaCollection * _result = 0;
    HRESULT _hr = get_namespaces(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMSchemaCollectionPtr(_result, false);
}

inline _variant_t IXMLDOMDocument2::Getschemas ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_schemas(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline void IXMLDOMDocument2::PutRefschemas ( const _variant_t & otherCollection ) {
    HRESULT _hr = putref_schemas(otherCollection);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLDOMParseErrorPtr IXMLDOMDocument2::validate ( ) {
    struct IXMLDOMParseError * _result = 0;
    HRESULT _hr = raw_validate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMParseErrorPtr(_result, false);
}

inline HRESULT IXMLDOMDocument2::setProperty ( _bstr_t name, const _variant_t & value ) {
    HRESULT _hr = raw_setProperty(name, value);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _variant_t IXMLDOMDocument2::getProperty ( _bstr_t name ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getProperty(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

//
// interface IXMLDOMNotation wrapper method implementations
//

inline _variant_t IXMLDOMNotation::GetpublicId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_publicId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _variant_t IXMLDOMNotation::GetsystemId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_systemId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

//
// interface IXMLDOMEntity wrapper method implementations
//

inline _variant_t IXMLDOMEntity::GetpublicId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_publicId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _variant_t IXMLDOMEntity::GetsystemId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_systemId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline _bstr_t IXMLDOMEntity::GetnotationName ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_notationName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IXTLRuntime wrapper method implementations
//

inline long IXTLRuntime::uniqueID ( struct IXMLDOMNode * pNode ) {
    long _result = 0;
    HRESULT _hr = raw_uniqueID(pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXTLRuntime::depth ( struct IXMLDOMNode * pNode ) {
    long _result = 0;
    HRESULT _hr = raw_depth(pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXTLRuntime::childNumber ( struct IXMLDOMNode * pNode ) {
    long _result = 0;
    HRESULT _hr = raw_childNumber(pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXTLRuntime::ancestorChildNumber ( _bstr_t bstrNodeName, struct IXMLDOMNode * pNode ) {
    long _result = 0;
    HRESULT _hr = raw_ancestorChildNumber(bstrNodeName, pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long IXTLRuntime::absoluteChildNumber ( struct IXMLDOMNode * pNode ) {
    long _result = 0;
    HRESULT _hr = raw_absoluteChildNumber(pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t IXTLRuntime::formatIndex ( long lIndex, _bstr_t bstrFormat ) {
    BSTR _result = 0;
    HRESULT _hr = raw_formatIndex(lIndex, bstrFormat, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXTLRuntime::formatNumber ( double dblNumber, _bstr_t bstrFormat ) {
    BSTR _result = 0;
    HRESULT _hr = raw_formatNumber(dblNumber, bstrFormat, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXTLRuntime::formatDate ( const _variant_t & varDate, _bstr_t bstrFormat, const _variant_t & varDestLocale ) {
    BSTR _result = 0;
    HRESULT _hr = raw_formatDate(varDate, bstrFormat, varDestLocale, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXTLRuntime::formatTime ( const _variant_t & varTime, _bstr_t bstrFormat, const _variant_t & varDestLocale ) {
    BSTR _result = 0;
    HRESULT _hr = raw_formatTime(varTime, bstrFormat, varDestLocale, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IXMLDOMSelection wrapper method implementations
//

inline _bstr_t IXMLDOMSelection::Getexpr ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_expr(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXMLDOMSelection::Putexpr ( _bstr_t expression ) {
    HRESULT _hr = put_expr(expression);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLDOMNodePtr IXMLDOMSelection::Getcontext ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_context(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline void IXMLDOMSelection::PutRefcontext ( struct IXMLDOMNode * ppNode ) {
    HRESULT _hr = putref_context(ppNode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLDOMNodePtr IXMLDOMSelection::peekNode ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_peekNode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMSelection::matches ( struct IXMLDOMNode * pNode ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_matches(pNode, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXMLDOMNodePtr IXMLDOMSelection::removeNext ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = raw_removeNext(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline HRESULT IXMLDOMSelection::removeAll ( ) {
    HRESULT _hr = raw_removeAll();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLDOMSelectionPtr IXMLDOMSelection::clone ( ) {
    struct IXMLDOMSelection * _result = 0;
    HRESULT _hr = raw_clone(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMSelectionPtr(_result, false);
}

inline _variant_t IXMLDOMSelection::getProperty ( _bstr_t name ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = raw_getProperty(name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline HRESULT IXMLDOMSelection::setProperty ( _bstr_t name, const _variant_t & value ) {
    HRESULT _hr = raw_setProperty(name, value);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface IDSOControl wrapper method implementations
//

inline IXMLDOMDocumentPtr IDSOControl::GetXMLDocument ( ) {
    struct IXMLDOMDocument * _result = 0;
    HRESULT _hr = get_XMLDocument(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMDocumentPtr(_result, false);
}

inline void IDSOControl::PutXMLDocument ( struct IXMLDOMDocument * ppDoc ) {
    HRESULT _hr = put_XMLDocument(ppDoc);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IDSOControl::GetJavaDSOCompatible ( ) {
    long _result = 0;
    HRESULT _hr = get_JavaDSOCompatible(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void IDSOControl::PutJavaDSOCompatible ( long fJavaDSOCompatible ) {
    HRESULT _hr = put_JavaDSOCompatible(fJavaDSOCompatible);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long IDSOControl::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

//
// interface IXSLTemplate wrapper method implementations
//

inline void IXSLTemplate::PutRefstylesheet ( struct IXMLDOMNode * stylesheet ) {
    HRESULT _hr = putref_stylesheet(stylesheet);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline IXMLDOMNodePtr IXSLTemplate::Getstylesheet ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_stylesheet(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}

inline IXSLProcessorPtr IXSLTemplate::createProcessor ( ) {
    struct IXSLProcessor * _result = 0;
    HRESULT _hr = raw_createProcessor(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXSLProcessorPtr(_result, false);
}

//
// interface IXSLProcessor wrapper method implementations
//

inline void IXSLProcessor::Putinput ( const _variant_t & pVar ) {
    HRESULT _hr = put_input(pVar);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IXSLProcessor::Getinput ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_input(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline IXSLTemplatePtr IXSLProcessor::GetownerTemplate ( ) {
    struct IXSLTemplate * _result = 0;
    HRESULT _hr = get_ownerTemplate(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXSLTemplatePtr(_result, false);
}

inline HRESULT IXSLProcessor::setStartMode ( _bstr_t mode, _bstr_t namespaceURI ) {
    HRESULT _hr = raw_setStartMode(mode, namespaceURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline _bstr_t IXSLProcessor::GetstartMode ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_startMode(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t IXSLProcessor::GetstartModeURI ( ) {
    BSTR _result = 0;
    HRESULT _hr = get_startModeURI(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void IXSLProcessor::Putoutput ( const _variant_t & pOutput ) {
    HRESULT _hr = put_output(pOutput);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline _variant_t IXSLProcessor::Getoutput ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_output(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

inline VARIANT_BOOL IXSLProcessor::transform ( ) {
    VARIANT_BOOL _result = 0;
    HRESULT _hr = raw_transform(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IXSLProcessor::reset ( ) {
    HRESULT _hr = raw_reset();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline long IXSLProcessor::GetreadyState ( ) {
    long _result = 0;
    HRESULT _hr = get_readyState(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline HRESULT IXSLProcessor::addParameter ( _bstr_t baseName, const _variant_t & parameter, _bstr_t namespaceURI ) {
    HRESULT _hr = raw_addParameter(baseName, parameter, namespaceURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT IXSLProcessor::addObject ( IDispatch * obj, _bstr_t namespaceURI ) {
    HRESULT _hr = raw_addObject(obj, namespaceURI);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline IXMLDOMNodePtr IXSLProcessor::Getstylesheet ( ) {
    struct IXMLDOMNode * _result = 0;
    HRESULT _hr = get_stylesheet(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IXMLDOMNodePtr(_result, false);
}