

// ##### BEGINFILE "CloudNetworkWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudNetwork.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDNETWORK

#include "CloudNetworkWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudNetworkWrap)

//
// ICloudNetwork properties
//

STDMETHODIMP CloudNetworkWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "CloudNetwork::getNetworkName", aNetworkName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkName);
        BSTROutConverter TmpNetworkName(aNetworkName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkName(TmpNetworkName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetworkName=%ls hrc=%Rhrc\n", this, "CloudNetwork::getNetworkName", !RT_VALID_PTR(aNetworkName) ? 0 : *aNetworkName, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMSETTER(NetworkName)(IN_BSTR aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls\n", this, "CloudNetwork::setNetworkName", aNetworkName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpNetworkName(aNetworkName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKNAME_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetworkName(TmpNetworkName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudNetwork::setNetworkName", hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "CloudNetwork::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "CloudNetwork::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "CloudNetwork::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudNetwork::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(Provider)(BSTR *aProvider)
{
    LogRelFlow(("{%p} %s: enter aProvider=%p\n", this, "CloudNetwork::getProvider", aProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProvider);
        BSTROutConverter TmpProvider(aProvider);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROVIDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProvider(TmpProvider.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROVIDER_RETURN(this, hrc, 0 /*normal*/,TmpProvider.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProvider=%ls hrc=%Rhrc\n", this, "CloudNetwork::getProvider", !RT_VALID_PTR(aProvider) ? 0 : *aProvider, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMSETTER(Provider)(IN_BSTR aProvider)
{
    LogRelFlow(("{%p} %s: enter aProvider=%ls\n", this, "CloudNetwork::setProvider", aProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProvider(aProvider);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROVIDER_ENTER(this, TmpProvider.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProvider(TmpProvider.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROVIDER_RETURN(this, hrc, 0 /*normal*/,TmpProvider.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudNetwork::setProvider", hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(Profile)(BSTR *aProfile)
{
    LogRelFlow(("{%p} %s: enter aProfile=%p\n", this, "CloudNetwork::getProfile", aProfile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProfile);
        BSTROutConverter TmpProfile(aProfile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProfile(TmpProfile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROFILE_RETURN(this, hrc, 0 /*normal*/,TmpProfile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_PROFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProfile=%ls hrc=%Rhrc\n", this, "CloudNetwork::getProfile", !RT_VALID_PTR(aProfile) ? 0 : *aProfile, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMSETTER(Profile)(IN_BSTR aProfile)
{
    LogRelFlow(("{%p} %s: enter aProfile=%ls\n", this, "CloudNetwork::setProfile", aProfile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProfile(aProfile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROFILE_ENTER(this, TmpProfile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProfile(TmpProfile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROFILE_RETURN(this, hrc, 0 /*normal*/,TmpProfile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_PROFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudNetwork::setProfile", hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(NetworkId)(BSTR *aNetworkId)
{
    LogRelFlow(("{%p} %s: enter aNetworkId=%p\n", this, "CloudNetwork::getNetworkId", aNetworkId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkId);
        BSTROutConverter TmpNetworkId(aNetworkId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkId(TmpNetworkId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKID_RETURN(this, hrc, 0 /*normal*/,TmpNetworkId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_GET_NETWORKID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetworkId=%ls hrc=%Rhrc\n", this, "CloudNetwork::getNetworkId", !RT_VALID_PTR(aNetworkId) ? 0 : *aNetworkId, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMSETTER(NetworkId)(IN_BSTR aNetworkId)
{
    LogRelFlow(("{%p} %s: enter aNetworkId=%ls\n", this, "CloudNetwork::setNetworkId", aNetworkId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpNetworkId(aNetworkId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKID_ENTER(this, TmpNetworkId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetworkId(TmpNetworkId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKID_RETURN(this, hrc, 0 /*normal*/,TmpNetworkId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORK_SET_NETWORKID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudNetwork::setNetworkId", hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute1ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute2ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute3ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute4ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute5ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute6ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute7ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute8ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute9ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute10ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute11ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::COMGETTER(InternalAndReservedAttribute12ICloudNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudNetwork methods
//

STDMETHODIMP CloudNetworkWrap::InternalAndReservedMethod1ICloudNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::InternalAndReservedMethod2ICloudNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::InternalAndReservedMethod3ICloudNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkWrap::InternalAndReservedMethod4ICloudNetwork()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudNetworkWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudNetworkWrap, ICloudNetwork)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudNetworkWrap.cpp"


// ##### BEGINFILE "DHCPServerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPServer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPSERVER

#include "DHCPServerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DHCPServerWrap)

//
// IDHCPServer properties
//

STDMETHODIMP DHCPServerWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "DHCPServer::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "DHCPServer::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "DHCPServer::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "DHCPServer::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "DHCPServer::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPServer::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(IPAddress)(BSTR *aIPAddress)
{
    LogRelFlow(("{%p} %s: enter aIPAddress=%p\n", this, "DHCPServer::getIPAddress", aIPAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIPAddress);
        BSTROutConverter TmpIPAddress(aIPAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_IPADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIPAddress(TmpIPAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_IPADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpIPAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_IPADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_IPADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIPAddress=%ls hrc=%Rhrc\n", this, "DHCPServer::getIPAddress", !RT_VALID_PTR(aIPAddress) ? 0 : *aIPAddress, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(NetworkMask)(BSTR *aNetworkMask)
{
    LogRelFlow(("{%p} %s: enter aNetworkMask=%p\n", this, "DHCPServer::getNetworkMask", aNetworkMask));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkMask);
        BSTROutConverter TmpNetworkMask(aNetworkMask);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKMASK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkMask(TmpNetworkMask.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKMASK_RETURN(this, hrc, 0 /*normal*/,TmpNetworkMask.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKMASK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKMASK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetworkMask=%ls hrc=%Rhrc\n", this, "DHCPServer::getNetworkMask", !RT_VALID_PTR(aNetworkMask) ? 0 : *aNetworkMask, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "DHCPServer::getNetworkName", aNetworkName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkName);
        BSTROutConverter TmpNetworkName(aNetworkName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkName(TmpNetworkName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetworkName=%ls hrc=%Rhrc\n", this, "DHCPServer::getNetworkName", !RT_VALID_PTR(aNetworkName) ? 0 : *aNetworkName, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(LowerIP)(BSTR *aLowerIP)
{
    LogRelFlow(("{%p} %s: enter aLowerIP=%p\n", this, "DHCPServer::getLowerIP", aLowerIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLowerIP);
        BSTROutConverter TmpLowerIP(aLowerIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_LOWERIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLowerIP(TmpLowerIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_LOWERIP_RETURN(this, hrc, 0 /*normal*/,TmpLowerIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_LOWERIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_LOWERIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLowerIP=%ls hrc=%Rhrc\n", this, "DHCPServer::getLowerIP", !RT_VALID_PTR(aLowerIP) ? 0 : *aLowerIP, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(UpperIP)(BSTR *aUpperIP)
{
    LogRelFlow(("{%p} %s: enter aUpperIP=%p\n", this, "DHCPServer::getUpperIP", aUpperIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUpperIP);
        BSTROutConverter TmpUpperIP(aUpperIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_UPPERIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUpperIP(TmpUpperIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_UPPERIP_RETURN(this, hrc, 0 /*normal*/,TmpUpperIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_UPPERIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_UPPERIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUpperIP=%ls hrc=%Rhrc\n", this, "DHCPServer::getUpperIP", !RT_VALID_PTR(aUpperIP) ? 0 : *aUpperIP, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(GlobalConfig)(IDHCPGlobalConfig **aGlobalConfig)
{
    LogRelFlow(("{%p} %s: enter aGlobalConfig=%p\n", this, "DHCPServer::getGlobalConfig", aGlobalConfig));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGlobalConfig);
        ComTypeOutConverter<IDHCPGlobalConfig> TmpGlobalConfig(aGlobalConfig);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GLOBALCONFIG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGlobalConfig(TmpGlobalConfig.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GLOBALCONFIG_RETURN(this, hrc, 0 /*normal*/,(void *)TmpGlobalConfig.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GLOBALCONFIG_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GLOBALCONFIG_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGlobalConfig=%p hrc=%Rhrc\n", this, "DHCPServer::getGlobalConfig", !RT_VALID_PTR(aGlobalConfig) ? 0 : *aGlobalConfig, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(GroupConfigs)(ComSafeArrayOut(IDHCPGroupConfig *, aGroupConfigs))
{
    LogRelFlow(("{%p} %s: enter aGroupConfigs=%p\n", this, "DHCPServer::getGroupConfigs", aGroupConfigs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroupConfigs);
        ArrayComTypeOutConverter<IDHCPGroupConfig> TmpGroupConfigs(ComSafeArrayOutArg(aGroupConfigs));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GROUPCONFIGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGroupConfigs(TmpGroupConfigs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GROUPCONFIGS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGroupConfigs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GROUPCONFIGS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_GROUPCONFIGS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGroupConfigs=%zu hrc=%Rhrc\n", this, "DHCPServer::getGroupConfigs", !RT_VALID_PTR(aGroupConfigs) ? 0 : ComSafeArraySize(*aGroupConfigs), hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(IndividualConfigs)(ComSafeArrayOut(IDHCPIndividualConfig *, aIndividualConfigs))
{
    LogRelFlow(("{%p} %s: enter aIndividualConfigs=%p\n", this, "DHCPServer::getIndividualConfigs", aIndividualConfigs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIndividualConfigs);
        ArrayComTypeOutConverter<IDHCPIndividualConfig> TmpIndividualConfigs(ComSafeArrayOutArg(aIndividualConfigs));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_INDIVIDUALCONFIGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIndividualConfigs(TmpIndividualConfigs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_INDIVIDUALCONFIGS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpIndividualConfigs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_INDIVIDUALCONFIGS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GET_INDIVIDUALCONFIGS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIndividualConfigs=%zu hrc=%Rhrc\n", this, "DHCPServer::getIndividualConfigs", !RT_VALID_PTR(aIndividualConfigs) ? 0 : ComSafeArraySize(*aIndividualConfigs), hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(InternalAndReservedAttribute1IDHCPServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(InternalAndReservedAttribute2IDHCPServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPServerWrap::COMGETTER(InternalAndReservedAttribute3IDHCPServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDHCPServer methods
//

STDMETHODIMP DHCPServerWrap::SetConfiguration(IN_BSTR aIPAddress,
                                              IN_BSTR aNetworkMask,
                                              IN_BSTR aFromIPAddress,
                                              IN_BSTR aToIPAddress)
{
    LogRelFlow(("{%p} %s: enter aIPAddress=%ls aNetworkMask=%ls aFromIPAddress=%ls aToIPAddress=%ls\n", this, "DHCPServer::setConfiguration", aIPAddress, aNetworkMask, aFromIPAddress, aToIPAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpIPAddress(aIPAddress);
        BSTRInConverter TmpNetworkMask(aNetworkMask);
        BSTRInConverter TmpFromIPAddress(aFromIPAddress);
        BSTRInConverter TmpToIPAddress(aToIPAddress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SETCONFIGURATION_ENTER(this, TmpIPAddress.str().c_str(), TmpNetworkMask.str().c_str(), TmpFromIPAddress.str().c_str(), TmpToIPAddress.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setConfiguration(TmpIPAddress.str(),
                                   TmpNetworkMask.str(),
                                   TmpFromIPAddress.str(),
                                   TmpToIPAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SETCONFIGURATION_RETURN(this, hrc, 0 /*normal*/, TmpIPAddress.str().c_str(), TmpNetworkMask.str().c_str(), TmpFromIPAddress.str().c_str(), TmpToIPAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SETCONFIGURATION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_SETCONFIGURATION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPServer::setConfiguration", hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::Start(IN_BSTR aTrunkName,
                                   IN_BSTR aTrunkType)
{
    LogRelFlow(("{%p} %s: enter aTrunkName=%ls aTrunkType=%ls\n", this, "DHCPServer::start", aTrunkName, aTrunkType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpTrunkName(aTrunkName);
        BSTRInConverter TmpTrunkType(aTrunkType);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_START_ENTER(this, TmpTrunkName.str().c_str(), TmpTrunkType.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = start(TmpTrunkName.str(),
                        TmpTrunkType.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_START_RETURN(this, hrc, 0 /*normal*/, TmpTrunkName.str().c_str(), TmpTrunkType.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_START_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_START_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPServer::start", hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::Stop()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPServer::stop"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_STOP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = stop();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_STOP_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_STOP_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_STOP_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPServer::stop", hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::Restart()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPServer::restart"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_RESTART_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = restart();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_RESTART_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_RESTART_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_RESTART_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPServer::restart", hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::FindLeaseByMAC(IN_BSTR aMac,
                                            LONG aType,
                                            BSTR *aAddress,
                                            BSTR *aState,
                                            LONG64 *aIssued,
                                            LONG64 *aExpire)
{
    LogRelFlow(("{%p} %s: enter aMac=%ls aType=%RI32 aAddress=%p aState=%p aIssued=%p aExpire=%p\n", this, "DHCPServer::findLeaseByMAC", aMac, aType, aAddress, aState, aIssued, aExpire));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAddress);
        CheckComArgOutPointerValidThrow(aState);
        CheckComArgOutPointerValidThrow(aIssued);
        CheckComArgOutPointerValidThrow(aExpire);


        BSTRInConverter TmpMac(aMac);
        
        BSTROutConverter TmpAddress(aAddress);
        BSTROutConverter TmpState(aState);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_FINDLEASEBYMAC_ENTER(this, TmpMac.str().c_str(), aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findLeaseByMAC(TmpMac.str(),
                                 aType,
                                 TmpAddress.str(),
                                 TmpState.str(),
                                 aIssued,
                                 aExpire);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_FINDLEASEBYMAC_RETURN(this, hrc, 0 /*normal*/, TmpMac.str().c_str(), aType, TmpAddress.str().c_str(), TmpState.str().c_str(), *aIssued, *aExpire);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_FINDLEASEBYMAC_RETURN(this, hrc, 1 /*hrc exception*/, 0, aType, 0, 0, *aIssued, *aExpire);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_FINDLEASEBYMAC_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aType, 0, 0, *aIssued, *aExpire);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAddress=%ls *aState=%ls *aIssued=%RI64 *aExpire=%RI64 hrc=%Rhrc\n", this, "DHCPServer::findLeaseByMAC", !RT_VALID_PTR(aAddress) ? 0 : *aAddress, !RT_VALID_PTR(aState) ? 0 : *aState, !RT_VALID_PTR(aIssued) ? 0 : *aIssued, !RT_VALID_PTR(aExpire) ? 0 : *aExpire, hrc));
    return hrc;
}

STDMETHODIMP DHCPServerWrap::GetConfig(DHCPConfigScope_T aScope,
                                       IN_BSTR aName,
                                       ULONG aSlot,
                                       BOOL aMayAdd,
                                       IDHCPConfig **aConfig)
{
    LogRelFlow(("{%p} %s: enter aScope=%RU32 aName=%ls aSlot=%RU32 aMayAdd=%RTbool aConfig=%p\n", this, "DHCPServer::getConfig", aScope, aName, aSlot, aMayAdd, aConfig));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConfig);


        
        BSTRInConverter TmpName(aName);
        
        
        ComTypeOutConverter<IDHCPConfig> TmpConfig(aConfig);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GETCONFIG_ENTER(this, aScope, TmpName.str().c_str(), aSlot, aMayAdd != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConfig(aScope,
                            TmpName.str(),
                            aSlot,
                            aMayAdd != FALSE,
                            TmpConfig.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GETCONFIG_RETURN(this, hrc, 0 /*normal*/, aScope, TmpName.str().c_str(), aSlot, aMayAdd != FALSE, (void *)TmpConfig.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GETCONFIG_RETURN(this, hrc, 1 /*hrc exception*/, aScope, 0, aSlot, aMayAdd != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPSERVER_GETCONFIG_RETURN(this, hrc, 9 /*unhandled exception*/, aScope, 0, aSlot, aMayAdd != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aConfig=%p hrc=%Rhrc\n", this, "DHCPServer::getConfig", !RT_VALID_PTR(aConfig) ? 0 : *aConfig, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPServerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DHCPServerWrap, IDHCPServer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPServerWrap.cpp"


// ##### BEGINFILE "DHCPGlobalConfigWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPGlobalConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPGLOBALCONFIG

#include "DHCPGlobalConfigWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DHCPGlobalConfigWrap)

//
// IDHCPConfig properties
//

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(Scope)(DHCPConfigScope_T *aScope)
{
    LogRelFlow(("{%p} %s: enter aScope=%p\n", this, "DHCPGlobalConfig::getScope", aScope));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScope);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SCOPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScope(aScope);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SCOPE_RETURN(this, hrc, 0 /*normal*/,*aScope);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SCOPE_RETURN(this, hrc, 1 /*hrc exception*/,*aScope);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SCOPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aScope);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScope=%RU32 hrc=%Rhrc\n", this, "DHCPGlobalConfig::getScope", !RT_VALID_PTR(aScope) ? 0 : *aScope, hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(MinLeaseTime)(ULONG *aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%p\n", this, "DHCPGlobalConfig::getMinLeaseTime", aMinLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MINLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aMinLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGlobalConfig::getMinLeaseTime", !RT_VALID_PTR(aMinLeaseTime) ? 0 : *aMinLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMSETTER(MinLeaseTime)(ULONG aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%RU32\n", this, "DHCPGlobalConfig::setMinLeaseTime", aMinLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MINLEASETIME_ENTER(this, aMinLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aMinLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMinLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setMinLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(DefaultLeaseTime)(ULONG *aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%p\n", this, "DHCPGlobalConfig::getDefaultLeaseTime", aDefaultLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_DEFAULTLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aDefaultLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGlobalConfig::getDefaultLeaseTime", !RT_VALID_PTR(aDefaultLeaseTime) ? 0 : *aDefaultLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMSETTER(DefaultLeaseTime)(ULONG aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%RU32\n", this, "DHCPGlobalConfig::setDefaultLeaseTime", aDefaultLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_DEFAULTLEASETIME_ENTER(this, aDefaultLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aDefaultLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setDefaultLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(MaxLeaseTime)(ULONG *aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%p\n", this, "DHCPGlobalConfig::getMaxLeaseTime", aMaxLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MAXLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGlobalConfig::getMaxLeaseTime", !RT_VALID_PTR(aMaxLeaseTime) ? 0 : *aMaxLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMSETTER(MaxLeaseTime)(ULONG aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%RU32\n", this, "DHCPGlobalConfig::setMaxLeaseTime", aMaxLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MAXLEASETIME_ENTER(this, aMaxLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aMaxLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setMaxLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(ForcedOptions)(ComSafeArrayOut(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%p\n", this, "DHCPGlobalConfig::getForcedOptions", aForcedOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aForcedOptions);
        ArrayOutConverter<DHCPOption_T> TmpForcedOptions(ComSafeArrayOutArg(aForcedOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_FORCEDOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getForcedOptions(TmpForcedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForcedOptions=%zu hrc=%Rhrc\n", this, "DHCPGlobalConfig::getForcedOptions", !RT_VALID_PTR(aForcedOptions) ? 0 : ComSafeArraySize(*aForcedOptions), hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMSETTER(ForcedOptions)(ComSafeArrayIn(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%zu\n", this, "DHCPGlobalConfig::setForcedOptions", ComSafeArraySize(aForcedOptions)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayInConverter<DHCPOption_T> TmpForcedOptions(ComSafeArrayInArg(aForcedOptions));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_FORCEDOPTIONS_ENTER(this, (uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setForcedOptions(TmpForcedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setForcedOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(SuppressedOptions)(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%p\n", this, "DHCPGlobalConfig::getSuppressedOptions", aSuppressedOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSuppressedOptions);
        ArrayOutConverter<DHCPOption_T> TmpSuppressedOptions(ComSafeArrayOutArg(aSuppressedOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SUPPRESSEDOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSuppressedOptions(TmpSuppressedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSuppressedOptions=%zu hrc=%Rhrc\n", this, "DHCPGlobalConfig::getSuppressedOptions", !RT_VALID_PTR(aSuppressedOptions) ? 0 : ComSafeArraySize(*aSuppressedOptions), hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMSETTER(SuppressedOptions)(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%zu\n", this, "DHCPGlobalConfig::setSuppressedOptions", ComSafeArraySize(aSuppressedOptions)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayInConverter<DHCPOption_T> TmpSuppressedOptions(ComSafeArrayInArg(aSuppressedOptions));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_SUPPRESSEDOPTIONS_ENTER(this, (uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSuppressedOptions(TmpSuppressedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setSuppressedOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute1IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute2IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute3IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute4IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute5IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute6IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute7IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute8IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute9IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute10IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute11IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute12IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute13IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute14IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute15IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute16IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDHCPGlobalConfig properties
//

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute1IDHCPGlobalConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute2IDHCPGlobalConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute3IDHCPGlobalConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::COMGETTER(InternalAndReservedAttribute4IDHCPGlobalConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDHCPConfig methods
//

STDMETHODIMP DHCPGlobalConfigWrap::SetOption(DHCPOption_T aOption,
                                             DHCPOptionEncoding_T aEncoding,
                                             IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%RU32 aValue=%ls\n", this, "DHCPGlobalConfig::setOption", aOption, aEncoding, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SETOPTION_ENTER(this, aOption, aEncoding, TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setOption(aOption,
                            aEncoding,
                            TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SETOPTION_RETURN(this, hrc, 0 /*normal*/, aOption, aEncoding, TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SETOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption, aEncoding, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_SETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, aEncoding, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::setOption", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::RemoveOption(DHCPOption_T aOption)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32\n", this, "DHCPGlobalConfig::removeOption", aOption));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeOption(aOption);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEOPTION_RETURN(this, hrc, 0 /*normal*/, aOption);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::removeOption", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::RemoveAllOptions()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGlobalConfig::removeAllOptions"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllOptions();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::removeAllOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::GetOption(DHCPOption_T aOption,
                                             DHCPOptionEncoding_T *aEncoding,
                                             BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%p aValue=%p\n", this, "DHCPGlobalConfig::getOption", aOption, aEncoding, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEncoding);
        CheckComArgOutPointerValidThrow(aValue);


        
        
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOption(aOption,
                            aEncoding,
                            TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETOPTION_RETURN(this, hrc, 0 /*normal*/, aOption, *aEncoding, TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption, *aEncoding, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, *aEncoding, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEncoding=%RU32 aValue=%ls hrc=%Rhrc\n", this, "DHCPGlobalConfig::getOption", !RT_VALID_PTR(aEncoding) ? 0 : *aEncoding, !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::GetAllOptions(ComSafeArrayOut(DHCPOption_T, aOptions),
                                                 ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                                                 ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aOptions=%p aEncodings=%p aValues=%p\n", this, "DHCPGlobalConfig::getAllOptions", aOptions, aEncodings, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOptions);
        CheckComArgOutPointerValidThrow(aEncodings);
        CheckComArgOutPointerValidThrow(aValues);


        ArrayOutConverter<DHCPOption_T> TmpOptions(ComSafeArrayOutArg(aOptions));
        ArrayOutConverter<DHCPOptionEncoding_T> TmpEncodings(ComSafeArrayOutArg(aEncodings));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllOptions(TmpOptions.array(),
                                TmpEncodings.array(),
                                TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETALLOPTIONS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpOptions.array().size(), NULL /*for now*/, (uint32_t)TmpEncodings.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_GETALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOptions=%zu *aEncodings=%zu aValues=%zu hrc=%Rhrc\n", this, "DHCPGlobalConfig::getAllOptions", !RT_VALID_PTR(aOptions) ? 0 : ComSafeArraySize(*aOptions), !RT_VALID_PTR(aEncodings) ? 0 : ComSafeArraySize(*aEncodings), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGlobalConfig::remove"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGLOBALCONFIG_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGlobalConfig::remove", hrc));
    return hrc;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod1IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod2IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod3IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod4IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod5IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod6IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod7IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod8IDHCPConfig()
{
    return E_NOTIMPL;
}

//
// IDHCPGlobalConfig methods
//

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod1IDHCPGlobalConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod2IDHCPGlobalConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod3IDHCPGlobalConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGlobalConfigWrap::InternalAndReservedMethod4IDHCPGlobalConfig()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPGlobalConfigWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DHCPGlobalConfigWrap, IDHCPGlobalConfig, IDHCPConfig)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPGlobalConfigWrap.cpp"


// ##### BEGINFILE "DHCPGroupConfigWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPGroupConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPGROUPCONFIG

#include "DHCPGroupConfigWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DHCPGroupConfigWrap)

//
// IDHCPConfig properties
//

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(Scope)(DHCPConfigScope_T *aScope)
{
    LogRelFlow(("{%p} %s: enter aScope=%p\n", this, "DHCPGroupConfig::getScope", aScope));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScope);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SCOPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScope(aScope);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SCOPE_RETURN(this, hrc, 0 /*normal*/,*aScope);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SCOPE_RETURN(this, hrc, 1 /*hrc exception*/,*aScope);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SCOPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aScope);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScope=%RU32 hrc=%Rhrc\n", this, "DHCPGroupConfig::getScope", !RT_VALID_PTR(aScope) ? 0 : *aScope, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(MinLeaseTime)(ULONG *aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%p\n", this, "DHCPGroupConfig::getMinLeaseTime", aMinLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MINLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aMinLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGroupConfig::getMinLeaseTime", !RT_VALID_PTR(aMinLeaseTime) ? 0 : *aMinLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(MinLeaseTime)(ULONG aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%RU32\n", this, "DHCPGroupConfig::setMinLeaseTime", aMinLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MINLEASETIME_ENTER(this, aMinLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aMinLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMinLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setMinLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(DefaultLeaseTime)(ULONG *aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%p\n", this, "DHCPGroupConfig::getDefaultLeaseTime", aDefaultLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_DEFAULTLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aDefaultLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGroupConfig::getDefaultLeaseTime", !RT_VALID_PTR(aDefaultLeaseTime) ? 0 : *aDefaultLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(DefaultLeaseTime)(ULONG aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%RU32\n", this, "DHCPGroupConfig::setDefaultLeaseTime", aDefaultLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_DEFAULTLEASETIME_ENTER(this, aDefaultLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aDefaultLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setDefaultLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(MaxLeaseTime)(ULONG *aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%p\n", this, "DHCPGroupConfig::getMaxLeaseTime", aMaxLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxLeaseTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MAXLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxLeaseTime=%RU32 hrc=%Rhrc\n", this, "DHCPGroupConfig::getMaxLeaseTime", !RT_VALID_PTR(aMaxLeaseTime) ? 0 : *aMaxLeaseTime, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(MaxLeaseTime)(ULONG aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%RU32\n", this, "DHCPGroupConfig::setMaxLeaseTime", aMaxLeaseTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MAXLEASETIME_ENTER(this, aMaxLeaseTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 1 /*hrc exception*/,aMaxLeaseTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxLeaseTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setMaxLeaseTime", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(ForcedOptions)(ComSafeArrayOut(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%p\n", this, "DHCPGroupConfig::getForcedOptions", aForcedOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aForcedOptions);
        ArrayOutConverter<DHCPOption_T> TmpForcedOptions(ComSafeArrayOutArg(aForcedOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_FORCEDOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getForcedOptions(TmpForcedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForcedOptions=%zu hrc=%Rhrc\n", this, "DHCPGroupConfig::getForcedOptions", !RT_VALID_PTR(aForcedOptions) ? 0 : ComSafeArraySize(*aForcedOptions), hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(ForcedOptions)(ComSafeArrayIn(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%zu\n", this, "DHCPGroupConfig::setForcedOptions", ComSafeArraySize(aForcedOptions)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayInConverter<DHCPOption_T> TmpForcedOptions(ComSafeArrayInArg(aForcedOptions));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_FORCEDOPTIONS_ENTER(this, (uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setForcedOptions(TmpForcedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpForcedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setForcedOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(SuppressedOptions)(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%p\n", this, "DHCPGroupConfig::getSuppressedOptions", aSuppressedOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSuppressedOptions);
        ArrayOutConverter<DHCPOption_T> TmpSuppressedOptions(ComSafeArrayOutArg(aSuppressedOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SUPPRESSEDOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSuppressedOptions(TmpSuppressedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSuppressedOptions=%zu hrc=%Rhrc\n", this, "DHCPGroupConfig::getSuppressedOptions", !RT_VALID_PTR(aSuppressedOptions) ? 0 : ComSafeArraySize(*aSuppressedOptions), hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(SuppressedOptions)(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%zu\n", this, "DHCPGroupConfig::setSuppressedOptions", ComSafeArraySize(aSuppressedOptions)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayInConverter<DHCPOption_T> TmpSuppressedOptions(ComSafeArrayInArg(aSuppressedOptions));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_SUPPRESSEDOPTIONS_ENTER(this, (uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSuppressedOptions(TmpSuppressedOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSuppressedOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setSuppressedOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute1IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute2IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute3IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute4IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute5IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute6IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute7IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute8IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute9IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute10IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute11IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute12IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute13IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute14IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute15IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute16IDHCPConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDHCPGroupConfig properties
//

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "DHCPGroupConfig::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "DHCPGroupConfig::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "DHCPGroupConfig::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setName", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(Conditions)(ComSafeArrayOut(IDHCPGroupCondition *, aConditions))
{
    LogRelFlow(("{%p} %s: enter aConditions=%p\n", this, "DHCPGroupConfig::getConditions", aConditions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConditions);
        ArrayComTypeOutConverter<IDHCPGroupCondition> TmpConditions(ComSafeArrayOutArg(aConditions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_CONDITIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConditions(TmpConditions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_CONDITIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpConditions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_CONDITIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GET_CONDITIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aConditions=%zu hrc=%Rhrc\n", this, "DHCPGroupConfig::getConditions", !RT_VALID_PTR(aConditions) ? 0 : ComSafeArraySize(*aConditions), hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute1IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute2IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute3IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute4IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute5IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute6IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute7IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::COMGETTER(InternalAndReservedAttribute8IDHCPGroupConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDHCPConfig methods
//

STDMETHODIMP DHCPGroupConfigWrap::SetOption(DHCPOption_T aOption,
                                            DHCPOptionEncoding_T aEncoding,
                                            IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%RU32 aValue=%ls\n", this, "DHCPGroupConfig::setOption", aOption, aEncoding, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SETOPTION_ENTER(this, aOption, aEncoding, TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setOption(aOption,
                            aEncoding,
                            TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SETOPTION_RETURN(this, hrc, 0 /*normal*/, aOption, aEncoding, TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SETOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption, aEncoding, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_SETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, aEncoding, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::setOption", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::RemoveOption(DHCPOption_T aOption)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32\n", this, "DHCPGroupConfig::removeOption", aOption));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeOption(aOption);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEOPTION_RETURN(this, hrc, 0 /*normal*/, aOption);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::removeOption", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::RemoveAllOptions()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGroupConfig::removeAllOptions"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllOptions();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::removeAllOptions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::GetOption(DHCPOption_T aOption,
                                            DHCPOptionEncoding_T *aEncoding,
                                            BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%p aValue=%p\n", this, "DHCPGroupConfig::getOption", aOption, aEncoding, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEncoding);
        CheckComArgOutPointerValidThrow(aValue);


        
        
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOption(aOption,
                            aEncoding,
                            TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETOPTION_RETURN(this, hrc, 0 /*normal*/, aOption, *aEncoding, TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption, *aEncoding, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, *aEncoding, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEncoding=%RU32 aValue=%ls hrc=%Rhrc\n", this, "DHCPGroupConfig::getOption", !RT_VALID_PTR(aEncoding) ? 0 : *aEncoding, !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::GetAllOptions(ComSafeArrayOut(DHCPOption_T, aOptions),
                                                ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                                                ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aOptions=%p aEncodings=%p aValues=%p\n", this, "DHCPGroupConfig::getAllOptions", aOptions, aEncodings, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOptions);
        CheckComArgOutPointerValidThrow(aEncodings);
        CheckComArgOutPointerValidThrow(aValues);


        ArrayOutConverter<DHCPOption_T> TmpOptions(ComSafeArrayOutArg(aOptions));
        ArrayOutConverter<DHCPOptionEncoding_T> TmpEncodings(ComSafeArrayOutArg(aEncodings));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllOptions(TmpOptions.array(),
                                TmpEncodings.array(),
                                TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETALLOPTIONS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpOptions.array().size(), NULL /*for now*/, (uint32_t)TmpEncodings.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_GETALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOptions=%zu *aEncodings=%zu aValues=%zu hrc=%Rhrc\n", this, "DHCPGroupConfig::getAllOptions", !RT_VALID_PTR(aOptions) ? 0 : ComSafeArraySize(*aOptions), !RT_VALID_PTR(aEncodings) ? 0 : ComSafeArraySize(*aEncodings), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGroupConfig::remove"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::remove", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod1IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod2IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod3IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod4IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod5IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod6IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod7IDHCPConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod8IDHCPConfig()
{
    return E_NOTIMPL;
}

//
// IDHCPGroupConfig methods
//

STDMETHODIMP DHCPGroupConfigWrap::AddCondition(BOOL aInclusive,
                                               DHCPGroupConditionType_T aType,
                                               IN_BSTR aValue,
                                               IDHCPGroupCondition **aCondition)
{
    LogRelFlow(("{%p} %s: enter aInclusive=%RTbool aType=%RU32 aValue=%ls aCondition=%p\n", this, "DHCPGroupConfig::addCondition", aInclusive, aType, aValue, aCondition));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCondition);


        
        
        BSTRInConverter TmpValue(aValue);
        ComTypeOutConverter<IDHCPGroupCondition> TmpCondition(aCondition);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_ADDCONDITION_ENTER(this, aInclusive != FALSE, aType, TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addCondition(aInclusive != FALSE,
                               aType,
                               TmpValue.str(),
                               TmpCondition.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_ADDCONDITION_RETURN(this, hrc, 0 /*normal*/, aInclusive != FALSE, aType, TmpValue.str().c_str(), (void *)TmpCondition.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_ADDCONDITION_RETURN(this, hrc, 1 /*hrc exception*/, aInclusive != FALSE, aType, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_ADDCONDITION_RETURN(this, hrc, 9 /*unhandled exception*/, aInclusive != FALSE, aType, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCondition=%p hrc=%Rhrc\n", this, "DHCPGroupConfig::addCondition", !RT_VALID_PTR(aCondition) ? 0 : *aCondition, hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::RemoveAllConditions()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGroupConfig::removeAllConditions"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLCONDITIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllConditions();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLCONDITIONS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLCONDITIONS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONFIG_REMOVEALLCONDITIONS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DHCPGroupConfig::removeAllConditions", hrc));
    return hrc;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod1IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod2IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod3IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod4IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod5IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod6IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod7IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConfigWrap::InternalAndReservedMethod8IDHCPGroupConfig()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPGroupConfigWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DHCPGroupConfigWrap, IDHCPGroupConfig, IDHCPConfig)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPGroupConfigWrap.cpp"


// ##### BEGINFILE "VirtualBoxWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVirtualBox.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALBOX

#include "VirtualBoxWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VirtualBoxWrap)

//
// IVirtualBox properties
//

STDMETHODIMP VirtualBoxWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "VirtualBox::getVersion", aVersion));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "VirtualBox::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(VersionNormalized)(BSTR *aVersionNormalized)
{
    LogRelFlow(("{%p} %s: enter aVersionNormalized=%p\n", this, "VirtualBox::getVersionNormalized", aVersionNormalized));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersionNormalized);
        BSTROutConverter TmpVersionNormalized(aVersionNormalized);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSIONNORMALIZED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersionNormalized(TmpVersionNormalized.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSIONNORMALIZED_RETURN(this, hrc, 0 /*normal*/,TmpVersionNormalized.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSIONNORMALIZED_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_VERSIONNORMALIZED_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersionNormalized=%ls hrc=%Rhrc\n", this, "VirtualBox::getVersionNormalized", !RT_VALID_PTR(aVersionNormalized) ? 0 : *aVersionNormalized, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "VirtualBox::getRevision", aRevision));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "VirtualBox::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(PackageType)(BSTR *aPackageType)
{
    LogRelFlow(("{%p} %s: enter aPackageType=%p\n", this, "VirtualBox::getPackageType", aPackageType));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPackageType);
        BSTROutConverter TmpPackageType(aPackageType);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PACKAGETYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPackageType(TmpPackageType.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PACKAGETYPE_RETURN(this, hrc, 0 /*normal*/,TmpPackageType.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PACKAGETYPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PACKAGETYPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPackageType=%ls hrc=%Rhrc\n", this, "VirtualBox::getPackageType", !RT_VALID_PTR(aPackageType) ? 0 : *aPackageType, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(APIVersion)(BSTR *aAPIVersion)
{
    LogRelFlow(("{%p} %s: enter aAPIVersion=%p\n", this, "VirtualBox::getAPIVersion", aAPIVersion));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAPIVersion);
        BSTROutConverter TmpAPIVersion(aAPIVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAPIVersion(TmpAPIVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIVERSION_RETURN(this, hrc, 0 /*normal*/,TmpAPIVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAPIVersion=%ls hrc=%Rhrc\n", this, "VirtualBox::getAPIVersion", !RT_VALID_PTR(aAPIVersion) ? 0 : *aAPIVersion, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(APIRevision)(LONG64 *aAPIRevision)
{
    LogRelFlow(("{%p} %s: enter aAPIRevision=%p\n", this, "VirtualBox::getAPIRevision", aAPIRevision));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAPIRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIREVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAPIRevision(aAPIRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIREVISION_RETURN(this, hrc, 0 /*normal*/,*aAPIRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIREVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aAPIRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_APIREVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aAPIRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAPIRevision=%RI64 hrc=%Rhrc\n", this, "VirtualBox::getAPIRevision", !RT_VALID_PTR(aAPIRevision) ? 0 : *aAPIRevision, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(HomeFolder)(BSTR *aHomeFolder)
{
    LogRelFlow(("{%p} %s: enter aHomeFolder=%p\n", this, "VirtualBox::getHomeFolder", aHomeFolder));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHomeFolder);
        BSTROutConverter TmpHomeFolder(aHomeFolder);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOMEFOLDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHomeFolder(TmpHomeFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOMEFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpHomeFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOMEFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOMEFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHomeFolder=%ls hrc=%Rhrc\n", this, "VirtualBox::getHomeFolder", !RT_VALID_PTR(aHomeFolder) ? 0 : *aHomeFolder, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(SettingsFilePath)(BSTR *aSettingsFilePath)
{
    LogRelFlow(("{%p} %s: enter aSettingsFilePath=%p\n", this, "VirtualBox::getSettingsFilePath", aSettingsFilePath));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSettingsFilePath);
        BSTROutConverter TmpSettingsFilePath(aSettingsFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SETTINGSFILEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSettingsFilePath(TmpSettingsFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SETTINGSFILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpSettingsFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SETTINGSFILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SETTINGSFILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSettingsFilePath=%ls hrc=%Rhrc\n", this, "VirtualBox::getSettingsFilePath", !RT_VALID_PTR(aSettingsFilePath) ? 0 : *aSettingsFilePath, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(Host)(IHost **aHost)
{
    LogRelFlow(("{%p} %s: enter aHost=%p\n", this, "VirtualBox::getHost", aHost));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHost);
        ComTypeOutConverter<IHost> TmpHost(aHost);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHost(TmpHost.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOST_RETURN(this, hrc, 0 /*normal*/,(void *)TmpHost.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOST_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOST_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHost=%p hrc=%Rhrc\n", this, "VirtualBox::getHost", !RT_VALID_PTR(aHost) ? 0 : *aHost, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(SystemProperties)(ISystemProperties **aSystemProperties)
{
    LogRelFlow(("{%p} %s: enter aSystemProperties=%p\n", this, "VirtualBox::getSystemProperties", aSystemProperties));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSystemProperties);
        ComTypeOutConverter<ISystemProperties> TmpSystemProperties(aSystemProperties);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SYSTEMPROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSystemProperties(TmpSystemProperties.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SYSTEMPROPERTIES_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSystemProperties.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SYSTEMPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SYSTEMPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSystemProperties=%p hrc=%Rhrc\n", this, "VirtualBox::getSystemProperties", !RT_VALID_PTR(aSystemProperties) ? 0 : *aSystemProperties, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(Machines)(ComSafeArrayOut(IMachine *, aMachines))
{
    LogRelFlow(("{%p} %s: enter aMachines=%p\n", this, "VirtualBox::getMachines", aMachines));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachines);
        ArrayComTypeOutConverter<IMachine> TmpMachines(ComSafeArrayOutArg(aMachines));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachines(TmpMachines.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMachines.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachines=%zu hrc=%Rhrc\n", this, "VirtualBox::getMachines", !RT_VALID_PTR(aMachines) ? 0 : ComSafeArraySize(*aMachines), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(MachineGroups)(ComSafeArrayOut(BSTR, aMachineGroups))
{
    LogRelFlow(("{%p} %s: enter aMachineGroups=%p\n", this, "VirtualBox::getMachineGroups", aMachineGroups));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachineGroups);
        ArrayBSTROutConverter TmpMachineGroups(ComSafeArrayOutArg(aMachineGroups));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINEGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachineGroups(TmpMachineGroups.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINEGROUPS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMachineGroups.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINEGROUPS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_MACHINEGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachineGroups=%zu hrc=%Rhrc\n", this, "VirtualBox::getMachineGroups", !RT_VALID_PTR(aMachineGroups) ? 0 : ComSafeArraySize(*aMachineGroups), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(HardDisks)(ComSafeArrayOut(IMedium *, aHardDisks))
{
    LogRelFlow(("{%p} %s: enter aHardDisks=%p\n", this, "VirtualBox::getHardDisks", aHardDisks));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardDisks);
        ArrayComTypeOutConverter<IMedium> TmpHardDisks(ComSafeArrayOutArg(aHardDisks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HARDDISKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardDisks(TmpHardDisks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HARDDISKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpHardDisks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HARDDISKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HARDDISKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardDisks=%zu hrc=%Rhrc\n", this, "VirtualBox::getHardDisks", !RT_VALID_PTR(aHardDisks) ? 0 : ComSafeArraySize(*aHardDisks), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(DVDImages)(ComSafeArrayOut(IMedium *, aDVDImages))
{
    LogRelFlow(("{%p} %s: enter aDVDImages=%p\n", this, "VirtualBox::getDVDImages", aDVDImages));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDVDImages);
        ArrayComTypeOutConverter<IMedium> TmpDVDImages(ComSafeArrayOutArg(aDVDImages));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DVDIMAGES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDVDImages(TmpDVDImages.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DVDIMAGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDVDImages.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DVDIMAGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DVDIMAGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDVDImages=%zu hrc=%Rhrc\n", this, "VirtualBox::getDVDImages", !RT_VALID_PTR(aDVDImages) ? 0 : ComSafeArraySize(*aDVDImages), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(FloppyImages)(ComSafeArrayOut(IMedium *, aFloppyImages))
{
    LogRelFlow(("{%p} %s: enter aFloppyImages=%p\n", this, "VirtualBox::getFloppyImages", aFloppyImages));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFloppyImages);
        ArrayComTypeOutConverter<IMedium> TmpFloppyImages(ComSafeArrayOutArg(aFloppyImages));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_FLOPPYIMAGES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFloppyImages(TmpFloppyImages.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_FLOPPYIMAGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFloppyImages.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_FLOPPYIMAGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_FLOPPYIMAGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFloppyImages=%zu hrc=%Rhrc\n", this, "VirtualBox::getFloppyImages", !RT_VALID_PTR(aFloppyImages) ? 0 : ComSafeArraySize(*aFloppyImages), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(ProgressOperations)(ComSafeArrayOut(IProgress *, aProgressOperations))
{
    LogRelFlow(("{%p} %s: enter aProgressOperations=%p\n", this, "VirtualBox::getProgressOperations", aProgressOperations));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgressOperations);
        ArrayComTypeOutConverter<IProgress> TmpProgressOperations(ComSafeArrayOutArg(aProgressOperations));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PROGRESSOPERATIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProgressOperations(TmpProgressOperations.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PROGRESSOPERATIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProgressOperations.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PROGRESSOPERATIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PROGRESSOPERATIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProgressOperations=%zu hrc=%Rhrc\n", this, "VirtualBox::getProgressOperations", !RT_VALID_PTR(aProgressOperations) ? 0 : ComSafeArraySize(*aProgressOperations), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(GuestOSTypes)(ComSafeArrayOut(IGuestOSType *, aGuestOSTypes))
{
    LogRelFlow(("{%p} %s: enter aGuestOSTypes=%p\n", this, "VirtualBox::getGuestOSTypes", aGuestOSTypes));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestOSTypes);
        ArrayComTypeOutConverter<IGuestOSType> TmpGuestOSTypes(ComSafeArrayOutArg(aGuestOSTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestOSTypes(TmpGuestOSTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGuestOSTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestOSTypes=%zu hrc=%Rhrc\n", this, "VirtualBox::getGuestOSTypes", !RT_VALID_PTR(aGuestOSTypes) ? 0 : ComSafeArraySize(*aGuestOSTypes), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(GuestOSFamilies)(ComSafeArrayOut(BSTR, aGuestOSFamilies))
{
    LogRelFlow(("{%p} %s: enter aGuestOSFamilies=%p\n", this, "VirtualBox::getGuestOSFamilies", aGuestOSFamilies));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestOSFamilies);
        ArrayBSTROutConverter TmpGuestOSFamilies(ComSafeArrayOutArg(aGuestOSFamilies));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSFAMILIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestOSFamilies(TmpGuestOSFamilies.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSFAMILIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGuestOSFamilies.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSFAMILIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GUESTOSFAMILIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestOSFamilies=%zu hrc=%Rhrc\n", this, "VirtualBox::getGuestOSFamilies", !RT_VALID_PTR(aGuestOSFamilies) ? 0 : ComSafeArraySize(*aGuestOSFamilies), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
{
    LogRelFlow(("{%p} %s: enter aSharedFolders=%p\n", this, "VirtualBox::getSharedFolders", aSharedFolders));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSharedFolders);
        ArrayComTypeOutConverter<ISharedFolder> TmpSharedFolders(ComSafeArrayOutArg(aSharedFolders));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SHAREDFOLDERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSharedFolders(TmpSharedFolders.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SHAREDFOLDERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSharedFolders.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SHAREDFOLDERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_SHAREDFOLDERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSharedFolders=%zu hrc=%Rhrc\n", this, "VirtualBox::getSharedFolders", !RT_VALID_PTR(aSharedFolders) ? 0 : ComSafeArraySize(*aSharedFolders), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(PerformanceCollector)(IPerformanceCollector **aPerformanceCollector)
{
    LogRelFlow(("{%p} %s: enter aPerformanceCollector=%p\n", this, "VirtualBox::getPerformanceCollector", aPerformanceCollector));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPerformanceCollector);
        ComTypeOutConverter<IPerformanceCollector> TmpPerformanceCollector(aPerformanceCollector);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PERFORMANCECOLLECTOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPerformanceCollector(TmpPerformanceCollector.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PERFORMANCECOLLECTOR_RETURN(this, hrc, 0 /*normal*/,(void *)TmpPerformanceCollector.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PERFORMANCECOLLECTOR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_PERFORMANCECOLLECTOR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPerformanceCollector=%p hrc=%Rhrc\n", this, "VirtualBox::getPerformanceCollector", !RT_VALID_PTR(aPerformanceCollector) ? 0 : *aPerformanceCollector, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(DHCPServers)(ComSafeArrayOut(IDHCPServer *, aDHCPServers))
{
    LogRelFlow(("{%p} %s: enter aDHCPServers=%p\n", this, "VirtualBox::getDHCPServers", aDHCPServers));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDHCPServers);
        ArrayComTypeOutConverter<IDHCPServer> TmpDHCPServers(ComSafeArrayOutArg(aDHCPServers));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DHCPSERVERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDHCPServers(TmpDHCPServers.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DHCPSERVERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDHCPServers.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DHCPSERVERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_DHCPSERVERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDHCPServers=%zu hrc=%Rhrc\n", this, "VirtualBox::getDHCPServers", !RT_VALID_PTR(aDHCPServers) ? 0 : ComSafeArraySize(*aDHCPServers), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(NATNetworks)(ComSafeArrayOut(INATNetwork *, aNATNetworks))
{
    LogRelFlow(("{%p} %s: enter aNATNetworks=%p\n", this, "VirtualBox::getNATNetworks", aNATNetworks));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNATNetworks);
        ArrayComTypeOutConverter<INATNetwork> TmpNATNetworks(ComSafeArrayOutArg(aNATNetworks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_NATNETWORKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNATNetworks(TmpNATNetworks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_NATNETWORKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpNATNetworks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_NATNETWORKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_NATNETWORKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNATNetworks=%zu hrc=%Rhrc\n", this, "VirtualBox::getNATNetworks", !RT_VALID_PTR(aNATNetworks) ? 0 : ComSafeArraySize(*aNATNetworks), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "VirtualBox::getEventSource", aEventSource));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "VirtualBox::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(ExtensionPackManager)(IExtPackManager **aExtensionPackManager)
{
    LogRelFlow(("{%p} %s: enter aExtensionPackManager=%p\n", this, "VirtualBox::getExtensionPackManager", aExtensionPackManager));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtensionPackManager);
        ComTypeOutConverter<IExtPackManager> TmpExtensionPackManager(aExtensionPackManager);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EXTENSIONPACKMANAGER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtensionPackManager(TmpExtensionPackManager.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EXTENSIONPACKMANAGER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpExtensionPackManager.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EXTENSIONPACKMANAGER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_EXTENSIONPACKMANAGER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtensionPackManager=%p hrc=%Rhrc\n", this, "VirtualBox::getExtensionPackManager", !RT_VALID_PTR(aExtensionPackManager) ? 0 : *aExtensionPackManager, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalNetworks)(ComSafeArrayOut(BSTR, aInternalNetworks))
{
    LogRelFlow(("{%p} %s: enter aInternalNetworks=%p\n", this, "VirtualBox::getInternalNetworks", aInternalNetworks));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInternalNetworks);
        ArrayBSTROutConverter TmpInternalNetworks(ComSafeArrayOutArg(aInternalNetworks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_INTERNALNETWORKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInternalNetworks(TmpInternalNetworks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_INTERNALNETWORKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpInternalNetworks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_INTERNALNETWORKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_INTERNALNETWORKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInternalNetworks=%zu hrc=%Rhrc\n", this, "VirtualBox::getInternalNetworks", !RT_VALID_PTR(aInternalNetworks) ? 0 : ComSafeArraySize(*aInternalNetworks), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(HostOnlyNetworks)(ComSafeArrayOut(IHostOnlyNetwork *, aHostOnlyNetworks))
{
    LogRelFlow(("{%p} %s: enter aHostOnlyNetworks=%p\n", this, "VirtualBox::getHostOnlyNetworks", aHostOnlyNetworks));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostOnlyNetworks);
        ArrayComTypeOutConverter<IHostOnlyNetwork> TmpHostOnlyNetworks(ComSafeArrayOutArg(aHostOnlyNetworks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOSTONLYNETWORKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostOnlyNetworks(TmpHostOnlyNetworks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOSTONLYNETWORKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpHostOnlyNetworks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOSTONLYNETWORKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_HOSTONLYNETWORKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostOnlyNetworks=%zu hrc=%Rhrc\n", this, "VirtualBox::getHostOnlyNetworks", !RT_VALID_PTR(aHostOnlyNetworks) ? 0 : ComSafeArraySize(*aHostOnlyNetworks), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(GenericNetworkDrivers)(ComSafeArrayOut(BSTR, aGenericNetworkDrivers))
{
    LogRelFlow(("{%p} %s: enter aGenericNetworkDrivers=%p\n", this, "VirtualBox::getGenericNetworkDrivers", aGenericNetworkDrivers));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGenericNetworkDrivers);
        ArrayBSTROutConverter TmpGenericNetworkDrivers(ComSafeArrayOutArg(aGenericNetworkDrivers));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GENERICNETWORKDRIVERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGenericNetworkDrivers(TmpGenericNetworkDrivers.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GENERICNETWORKDRIVERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGenericNetworkDrivers.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GENERICNETWORKDRIVERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_GENERICNETWORKDRIVERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGenericNetworkDrivers=%zu hrc=%Rhrc\n", this, "VirtualBox::getGenericNetworkDrivers", !RT_VALID_PTR(aGenericNetworkDrivers) ? 0 : ComSafeArraySize(*aGenericNetworkDrivers), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(CloudNetworks)(ComSafeArrayOut(ICloudNetwork *, aCloudNetworks))
{
    LogRelFlow(("{%p} %s: enter aCloudNetworks=%p\n", this, "VirtualBox::getCloudNetworks", aCloudNetworks));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudNetworks);
        ArrayComTypeOutConverter<ICloudNetwork> TmpCloudNetworks(ComSafeArrayOutArg(aCloudNetworks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDNETWORKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudNetworks(TmpCloudNetworks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDNETWORKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpCloudNetworks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDNETWORKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDNETWORKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudNetworks=%zu hrc=%Rhrc\n", this, "VirtualBox::getCloudNetworks", !RT_VALID_PTR(aCloudNetworks) ? 0 : ComSafeArraySize(*aCloudNetworks), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(CloudProviderManager)(ICloudProviderManager **aCloudProviderManager)
{
    LogRelFlow(("{%p} %s: enter aCloudProviderManager=%p\n", this, "VirtualBox::getCloudProviderManager", aCloudProviderManager));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudProviderManager);
        ComTypeOutConverter<ICloudProviderManager> TmpCloudProviderManager(aCloudProviderManager);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDPROVIDERMANAGER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudProviderManager(TmpCloudProviderManager.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDPROVIDERMANAGER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpCloudProviderManager.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDPROVIDERMANAGER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GET_CLOUDPROVIDERMANAGER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudProviderManager=%p hrc=%Rhrc\n", this, "VirtualBox::getCloudProviderManager", !RT_VALID_PTR(aCloudProviderManager) ? 0 : *aCloudProviderManager, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute1IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute2IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute3IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute4IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute5IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute6IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute7IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute8IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute9IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute10IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute11IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::COMGETTER(InternalAndReservedAttribute12IVirtualBox)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVirtualBox methods
//

STDMETHODIMP VirtualBoxWrap::ComposeMachineFilename(IN_BSTR aName,
                                                    IN_BSTR aGroup,
                                                    IN_BSTR aCreateFlags,
                                                    IN_BSTR aBaseFolder,
                                                    BSTR *aFile)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aGroup=%ls aCreateFlags=%ls aBaseFolder=%ls aFile=%p\n", this, "VirtualBox::composeMachineFilename", aName, aGroup, aCreateFlags, aBaseFolder, aFile));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpGroup(aGroup);
        BSTRInConverter TmpCreateFlags(aCreateFlags);
        BSTRInConverter TmpBaseFolder(aBaseFolder);
        BSTROutConverter TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_COMPOSEMACHINEFILENAME_ENTER(this, TmpName.str().c_str(), TmpGroup.str().c_str(), TmpCreateFlags.str().c_str(), TmpBaseFolder.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = composeMachineFilename(TmpName.str(),
                                         TmpGroup.str(),
                                         TmpCreateFlags.str(),
                                         TmpBaseFolder.str(),
                                         TmpFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_COMPOSEMACHINEFILENAME_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpGroup.str().c_str(), TmpCreateFlags.str().c_str(), TmpBaseFolder.str().c_str(), TmpFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_COMPOSEMACHINEFILENAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_COMPOSEMACHINEFILENAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%ls hrc=%Rhrc\n", this, "VirtualBox::composeMachineFilename", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetPlatformProperties(PlatformArchitecture_T aArchitecture,
                                                   IPlatformProperties **aProperties)
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%RU32 aProperties=%p\n", this, "VirtualBox::getPlatformProperties", aArchitecture, aProperties));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProperties);


        
        ComTypeOutConverter<IPlatformProperties> TmpProperties(aProperties);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETPLATFORMPROPERTIES_ENTER(this, aArchitecture);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlatformProperties(aArchitecture,
                                        TmpProperties.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETPLATFORMPROPERTIES_RETURN(this, hrc, 0 /*normal*/, aArchitecture, (void *)TmpProperties.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETPLATFORMPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, aArchitecture, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETPLATFORMPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, aArchitecture, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProperties=%p hrc=%Rhrc\n", this, "VirtualBox::getPlatformProperties", !RT_VALID_PTR(aProperties) ? 0 : *aProperties, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateMachine(IN_BSTR aSettingsFile,
                                           IN_BSTR aName,
                                           PlatformArchitecture_T aPlatform,
                                           ComSafeArrayIn(IN_BSTR, aGroups),
                                           IN_BSTR aOsTypeId,
                                           IN_BSTR aFlags,
                                           IN_BSTR aCipher,
                                           IN_BSTR aPasswordId,
                                           IN_BSTR aPassword,
                                           IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aSettingsFile=%ls aName=%ls aPlatform=%RU32 aGroups=%zu aOsTypeId=%ls aFlags=%ls aCipher=%ls aPasswordId=%ls aPassword=%ls aMachine=%p\n", this, "VirtualBox::createMachine", aSettingsFile, aName, aPlatform, aGroups, aOsTypeId, aFlags, aCipher, aPasswordId, aPassword, aMachine));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


        BSTRInConverter TmpSettingsFile(aSettingsFile);
        BSTRInConverter TmpName(aName);
        
        ArrayBSTRInConverter TmpGroups(ComSafeArrayInArg(aGroups));
        BSTRInConverter TmpOsTypeId(aOsTypeId);
        BSTRInConverter TmpFlags(aFlags);
        BSTRInConverter TmpCipher(aCipher);
        BSTRInConverter TmpPasswordId(aPasswordId);
        BSTRInConverter TmpPassword(aPassword);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMACHINE_ENTER(this, TmpSettingsFile.str().c_str(), TmpName.str().c_str(), aPlatform, (uint32_t)TmpGroups.array().size(), NULL /*for now*/, TmpOsTypeId.str().c_str(), TmpFlags.str().c_str(), TmpCipher.str().c_str(), TmpPasswordId.str().c_str(), TmpPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createMachine(TmpSettingsFile.str(),
                                TmpName.str(),
                                aPlatform,
                                TmpGroups.array(),
                                TmpOsTypeId.str(),
                                TmpFlags.str(),
                                TmpCipher.str(),
                                TmpPasswordId.str(),
                                TmpPassword.str(),
                                TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMACHINE_RETURN(this, hrc, 0 /*normal*/, TmpSettingsFile.str().c_str(), TmpName.str().c_str(), aPlatform, (uint32_t)TmpGroups.array().size(), NULL /*for now*/, TmpOsTypeId.str().c_str(), TmpFlags.str().c_str(), TmpCipher.str().c_str(), TmpPasswordId.str().c_str(), TmpPassword.str().c_str(), (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aPlatform, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aPlatform, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMachine=%p hrc=%Rhrc\n", this, "VirtualBox::createMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::OpenMachine(IN_BSTR aSettingsFile,
                                         IN_BSTR aPassword,
                                         IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aSettingsFile=%ls aPassword=%ls aMachine=%p\n", this, "VirtualBox::openMachine", aSettingsFile, aPassword, aMachine));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


        BSTRInConverter TmpSettingsFile(aSettingsFile);
        BSTRInConverter TmpPassword(aPassword);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMACHINE_ENTER(this, TmpSettingsFile.str().c_str(), TmpPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = openMachine(TmpSettingsFile.str(),
                              TmpPassword.str(),
                              TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMACHINE_RETURN(this, hrc, 0 /*normal*/, TmpSettingsFile.str().c_str(), TmpPassword.str().c_str(), (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMachine=%p hrc=%Rhrc\n", this, "VirtualBox::openMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RegisterMachine(IMachine *aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "VirtualBox::registerMachine", aMachine));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REGISTERMACHINE_ENTER(this, (void *)TmpMachine.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = registerMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REGISTERMACHINE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REGISTERMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REGISTERMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::registerMachine", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindMachine(IN_BSTR aNameOrId,
                                         IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aNameOrId=%ls aMachine=%p\n", this, "VirtualBox::findMachine", aNameOrId, aMachine));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


        BSTRInConverter TmpNameOrId(aNameOrId);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDMACHINE_ENTER(this, TmpNameOrId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findMachine(TmpNameOrId.str(),
                              TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDMACHINE_RETURN(this, hrc, 0 /*normal*/, TmpNameOrId.str().c_str(), (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMachine=%p hrc=%Rhrc\n", this, "VirtualBox::findMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetMachinesByGroups(ComSafeArrayIn(IN_BSTR, aGroups),
                                                 ComSafeArrayOut(IMachine *, aMachines))
{
    LogRelFlow(("{%p} %s: enter aGroups=%zu aMachines=%p\n", this, "VirtualBox::getMachinesByGroups", aGroups, aMachines));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachines);


        ArrayBSTRInConverter TmpGroups(ComSafeArrayInArg(aGroups));
        ArrayComTypeOutConverter<IMachine> TmpMachines(ComSafeArrayOutArg(aMachines));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESBYGROUPS_ENTER(this, (uint32_t)TmpGroups.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachinesByGroups(TmpGroups.array(),
                                      TmpMachines.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESBYGROUPS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpGroups.array().size(), NULL /*for now*/, (uint32_t)TmpMachines.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESBYGROUPS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESBYGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMachines=%zu hrc=%Rhrc\n", this, "VirtualBox::getMachinesByGroups", !RT_VALID_PTR(aMachines) ? 0 : ComSafeArraySize(*aMachines), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetMachineStates(ComSafeArrayIn(IMachine *, aMachines),
                                              ComSafeArrayOut(MachineState_T, aStates))
{
    LogRelFlow(("{%p} %s: enter aMachines=%zu aStates=%p\n", this, "VirtualBox::getMachineStates", aMachines, aStates));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStates);


        ArrayComTypeInConverter<IMachine> TmpMachines(ComSafeArrayInArg(aMachines));
        ArrayOutConverter<MachineState_T> TmpStates(ComSafeArrayOutArg(aStates));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESTATES_ENTER(this, (uint32_t)TmpMachines.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachineStates(TmpMachines.array(),
                                   TmpStates.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESTATES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMachines.array().size(), NULL /*for now*/, (uint32_t)TmpStates.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESTATES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETMACHINESTATES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aStates=%zu hrc=%Rhrc\n", this, "VirtualBox::getMachineStates", !RT_VALID_PTR(aStates) ? 0 : ComSafeArraySize(*aStates), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateAppliance(IAppliance **aAppliance)
{
    LogRelFlow(("{%p} %s: enter aAppliance=%p\n", this, "VirtualBox::createAppliance", aAppliance));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAppliance);


        ComTypeOutConverter<IAppliance> TmpAppliance(aAppliance);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEAPPLIANCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createAppliance(TmpAppliance.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEAPPLIANCE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpAppliance.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEAPPLIANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEAPPLIANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAppliance=%p hrc=%Rhrc\n", this, "VirtualBox::createAppliance", !RT_VALID_PTR(aAppliance) ? 0 : *aAppliance, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateUnattendedInstaller(IUnattended **aUnattended)
{
    LogRelFlow(("{%p} %s: enter aUnattended=%p\n", this, "VirtualBox::createUnattendedInstaller", aUnattended));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUnattended);


        ComTypeOutConverter<IUnattended> TmpUnattended(aUnattended);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEUNATTENDEDINSTALLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createUnattendedInstaller(TmpUnattended.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEUNATTENDEDINSTALLER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpUnattended.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEUNATTENDEDINSTALLER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEUNATTENDEDINSTALLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aUnattended=%p hrc=%Rhrc\n", this, "VirtualBox::createUnattendedInstaller", !RT_VALID_PTR(aUnattended) ? 0 : *aUnattended, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateMedium(IN_BSTR aFormat,
                                          IN_BSTR aLocation,
                                          AccessMode_T aAccessMode,
                                          DeviceType_T aADeviceTypeType,
                                          IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aLocation=%ls aAccessMode=%RU32 aADeviceTypeType=%RU32 aMedium=%p\n", this, "VirtualBox::createMedium", aFormat, aLocation, aAccessMode, aADeviceTypeType, aMedium));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);


        BSTRInConverter TmpFormat(aFormat);
        BSTRInConverter TmpLocation(aLocation);
        
        
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMEDIUM_ENTER(this, TmpFormat.str().c_str(), TmpLocation.str().c_str(), aAccessMode, aADeviceTypeType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createMedium(TmpFormat.str(),
                               TmpLocation.str(),
                               aAccessMode,
                               aADeviceTypeType,
                               TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), TmpLocation.str().c_str(), aAccessMode, aADeviceTypeType, (void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aAccessMode, aADeviceTypeType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aAccessMode, aADeviceTypeType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMedium=%p hrc=%Rhrc\n", this, "VirtualBox::createMedium", !RT_VALID_PTR(aMedium) ? 0 : *aMedium, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::OpenMedium(IN_BSTR aLocation,
                                        DeviceType_T aDeviceType,
                                        AccessMode_T aAccessMode,
                                        BOOL aForceNewUuid,
                                        IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aLocation=%ls aDeviceType=%RU32 aAccessMode=%RU32 aForceNewUuid=%RTbool aMedium=%p\n", this, "VirtualBox::openMedium", aLocation, aDeviceType, aAccessMode, aForceNewUuid, aMedium));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);


        BSTRInConverter TmpLocation(aLocation);
        
        
        
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMEDIUM_ENTER(this, TmpLocation.str().c_str(), aDeviceType, aAccessMode, aForceNewUuid != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = openMedium(TmpLocation.str(),
                             aDeviceType,
                             aAccessMode,
                             aForceNewUuid != FALSE,
                             TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpLocation.str().c_str(), aDeviceType, aAccessMode, aForceNewUuid != FALSE, (void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aDeviceType, aAccessMode, aForceNewUuid != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_OPENMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aDeviceType, aAccessMode, aForceNewUuid != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMedium=%p hrc=%Rhrc\n", this, "VirtualBox::openMedium", !RT_VALID_PTR(aMedium) ? 0 : *aMedium, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetGuestOSType(IN_BSTR aId,
                                            IGuestOSType **aType)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aType=%p\n", this, "VirtualBox::getGuestOSType", aId, aType));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);


        BSTRInConverter TmpId(aId);
        ComTypeOutConverter<IGuestOSType> TmpType(aType);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSTYPE_ENTER(this, TmpId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestOSType(TmpId.str(),
                                 TmpType.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSTYPE_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str(), (void *)TmpType.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSTYPE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aType=%p hrc=%Rhrc\n", this, "VirtualBox::getGuestOSType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetGuestOSSubtypesByFamilyId(IN_BSTR aFamily,
                                                          ComSafeArrayOut(BSTR, aOSsubtypes))
{
    LogRelFlow(("{%p} %s: enter aFamily=%ls aOSsubtypes=%p\n", this, "VirtualBox::getGuestOSSubtypesByFamilyId", aFamily, aOSsubtypes));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOSsubtypes);


        BSTRInConverter TmpFamily(aFamily);
        ArrayBSTROutConverter TmpOSsubtypes(ComSafeArrayOutArg(aOSsubtypes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSSUBTYPESBYFAMILYID_ENTER(this, TmpFamily.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestOSSubtypesByFamilyId(TmpFamily.str(),
                                               TmpOSsubtypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSSUBTYPESBYFAMILYID_RETURN(this, hrc, 0 /*normal*/, TmpFamily.str().c_str(), (uint32_t)TmpOSsubtypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSSUBTYPESBYFAMILYID_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSSUBTYPESBYFAMILYID_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aOSsubtypes=%zu hrc=%Rhrc\n", this, "VirtualBox::getGuestOSSubtypesByFamilyId", !RT_VALID_PTR(aOSsubtypes) ? 0 : ComSafeArraySize(*aOSsubtypes), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetGuestOSDescsBySubtype(IN_BSTR aOSSubtype,
                                                      ComSafeArrayOut(BSTR, aGuestOSDescs))
{
    LogRelFlow(("{%p} %s: enter aOSSubtype=%ls aGuestOSDescs=%p\n", this, "VirtualBox::getGuestOSDescsBySubtype", aOSSubtype, aGuestOSDescs));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestOSDescs);


        BSTRInConverter TmpOSSubtype(aOSSubtype);
        ArrayBSTROutConverter TmpGuestOSDescs(ComSafeArrayOutArg(aGuestOSDescs));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSDESCSBYSUBTYPE_ENTER(this, TmpOSSubtype.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestOSDescsBySubtype(TmpOSSubtype.str(),
                                           TmpGuestOSDescs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSDESCSBYSUBTYPE_RETURN(this, hrc, 0 /*normal*/, TmpOSSubtype.str().c_str(), (uint32_t)TmpGuestOSDescs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSDESCSBYSUBTYPE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETGUESTOSDESCSBYSUBTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestOSDescs=%zu hrc=%Rhrc\n", this, "VirtualBox::getGuestOSDescsBySubtype", !RT_VALID_PTR(aGuestOSDescs) ? 0 : ComSafeArraySize(*aGuestOSDescs), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateSharedFolder(IN_BSTR aName,
                                                IN_BSTR aHostPath,
                                                BOOL aWritable,
                                                BOOL aAutomount,
                                                IN_BSTR aAutoMountPoint)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aHostPath=%ls aWritable=%RTbool aAutomount=%RTbool aAutoMountPoint=%ls\n", this, "VirtualBox::createSharedFolder", aName, aHostPath, aWritable, aAutomount, aAutoMountPoint));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpHostPath(aHostPath);
        
        
        BSTRInConverter TmpAutoMountPoint(aAutoMountPoint);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATESHAREDFOLDER_ENTER(this, TmpName.str().c_str(), TmpHostPath.str().c_str(), aWritable != FALSE, aAutomount != FALSE, TmpAutoMountPoint.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createSharedFolder(TmpName.str(),
                                     TmpHostPath.str(),
                                     aWritable != FALSE,
                                     aAutomount != FALSE,
                                     TmpAutoMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATESHAREDFOLDER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpHostPath.str().c_str(), aWritable != FALSE, aAutomount != FALSE, TmpAutoMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATESHAREDFOLDER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aWritable != FALSE, aAutomount != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aWritable != FALSE, aAutomount != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::createSharedFolder", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RemoveSharedFolder(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "VirtualBox::removeSharedFolder", aName));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVESHAREDFOLDER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeSharedFolder(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVESHAREDFOLDER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVESHAREDFOLDER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::removeSharedFolder", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
{
    LogRelFlow(("{%p} %s: enter aKeys=%p\n", this, "VirtualBox::getExtraDataKeys", aKeys));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeys);


        ArrayBSTROutConverter TmpKeys(ComSafeArrayOutArg(aKeys));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATAKEYS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtraDataKeys(TmpKeys.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATAKEYS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpKeys.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATAKEYS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATAKEYS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aKeys=%zu hrc=%Rhrc\n", this, "VirtualBox::getExtraDataKeys", !RT_VALID_PTR(aKeys) ? 0 : ComSafeArraySize(*aKeys), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetExtraData(IN_BSTR aKey,
                                          BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "VirtualBox::getExtraData", aKey, aValue));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpKey(aKey);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATA_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtraData(TmpKey.str(),
                               TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATA_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETEXTRADATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "VirtualBox::getExtraData", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::SetExtraData(IN_BSTR aKey,
                                          IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%ls\n", this, "VirtualBox::setExtraData", aKey, aValue));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpKey(aKey);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETEXTRADATA_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setExtraData(TmpKey.str(),
                               TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETEXTRADATA_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETEXTRADATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETEXTRADATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::setExtraData", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::SetSettingsSecret(IN_BSTR aPassword)
{
    LogRelFlow(("{%p} %s: enter aPassword=%ls\n", this, "VirtualBox::setSettingsSecret", aPassword));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPassword(aPassword);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETSETTINGSSECRET_ENTER(this, TmpPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSettingsSecret(TmpPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETSETTINGSSECRET_RETURN(this, hrc, 0 /*normal*/, TmpPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETSETTINGSSECRET_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_SETSETTINGSSECRET_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::setSettingsSecret", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateDHCPServer(IN_BSTR aName,
                                              IDHCPServer **aServer)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aServer=%p\n", this, "VirtualBox::createDHCPServer", aName, aServer));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IDHCPServer> TmpServer(aServer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEDHCPSERVER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createDHCPServer(TmpName.str(),
                                   TmpServer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEDHCPSERVER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpServer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEDHCPSERVER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEDHCPSERVER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aServer=%p hrc=%Rhrc\n", this, "VirtualBox::createDHCPServer", !RT_VALID_PTR(aServer) ? 0 : *aServer, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindDHCPServerByNetworkName(IN_BSTR aName,
                                                         IDHCPServer **aServer)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aServer=%p\n", this, "VirtualBox::findDHCPServerByNetworkName", aName, aServer));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IDHCPServer> TmpServer(aServer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDDHCPSERVERBYNETWORKNAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findDHCPServerByNetworkName(TmpName.str(),
                                              TmpServer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDDHCPSERVERBYNETWORKNAME_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpServer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDDHCPSERVERBYNETWORKNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDDHCPSERVERBYNETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aServer=%p hrc=%Rhrc\n", this, "VirtualBox::findDHCPServerByNetworkName", !RT_VALID_PTR(aServer) ? 0 : *aServer, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RemoveDHCPServer(IDHCPServer *aServer)
{
    LogRelFlow(("{%p} %s: enter aServer=%p\n", this, "VirtualBox::removeDHCPServer", aServer));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IDHCPServer> TmpServer(aServer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEDHCPSERVER_ENTER(this, (void *)TmpServer.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeDHCPServer(TmpServer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEDHCPSERVER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpServer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEDHCPSERVER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEDHCPSERVER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::removeDHCPServer", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateNATNetwork(IN_BSTR aNetworkName,
                                              INATNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::createNATNetwork", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<INATNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATENATNETWORK_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createNATNetwork(TmpNetworkName.str(),
                                   TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATENATNETWORK_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATENATNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATENATNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::createNATNetwork", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindNATNetworkByName(IN_BSTR aNetworkName,
                                                  INATNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::findNATNetworkByName", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<INATNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDNATNETWORKBYNAME_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findNATNetworkByName(TmpNetworkName.str(),
                                       TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDNATNETWORKBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDNATNETWORKBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDNATNETWORKBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::findNATNetworkByName", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RemoveNATNetwork(INATNetwork *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "VirtualBox::removeNATNetwork", aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<INATNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVENATNETWORK_ENTER(this, (void *)TmpNetwork.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeNATNetwork(TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVENATNETWORK_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVENATNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVENATNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::removeNATNetwork", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateHostOnlyNetwork(IN_BSTR aNetworkName,
                                                   IHostOnlyNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::createHostOnlyNetwork", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<IHostOnlyNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEHOSTONLYNETWORK_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createHostOnlyNetwork(TmpNetworkName.str(),
                                        TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEHOSTONLYNETWORK_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEHOSTONLYNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATEHOSTONLYNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::createHostOnlyNetwork", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindHostOnlyNetworkByName(IN_BSTR aNetworkName,
                                                       IHostOnlyNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::findHostOnlyNetworkByName", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<IHostOnlyNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYNAME_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findHostOnlyNetworkByName(TmpNetworkName.str(),
                                            TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::findHostOnlyNetworkByName", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindHostOnlyNetworkById(IN_BSTR aId,
                                                     IHostOnlyNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aNetwork=%p\n", this, "VirtualBox::findHostOnlyNetworkById", aId, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IHostOnlyNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYID_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findHostOnlyNetworkById(TmpId.uuid(),
                                          TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYID_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYID_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDHOSTONLYNETWORKBYID_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::findHostOnlyNetworkById", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RemoveHostOnlyNetwork(IHostOnlyNetwork *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "VirtualBox::removeHostOnlyNetwork", aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IHostOnlyNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEHOSTONLYNETWORK_ENTER(this, (void *)TmpNetwork.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeHostOnlyNetwork(TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEHOSTONLYNETWORK_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEHOSTONLYNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVEHOSTONLYNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::removeHostOnlyNetwork", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CreateCloudNetwork(IN_BSTR aNetworkName,
                                                ICloudNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::createCloudNetwork", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<ICloudNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATECLOUDNETWORK_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createCloudNetwork(TmpNetworkName.str(),
                                     TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATECLOUDNETWORK_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATECLOUDNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CREATECLOUDNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::createCloudNetwork", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindCloudNetworkByName(IN_BSTR aNetworkName,
                                                    ICloudNetwork **aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls aNetwork=%p\n", this, "VirtualBox::findCloudNetworkByName", aNetworkName, aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


        BSTRInConverter TmpNetworkName(aNetworkName);
        ComTypeOutConverter<ICloudNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDCLOUDNETWORKBYNAME_ENTER(this, TmpNetworkName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findCloudNetworkByName(TmpNetworkName.str(),
                                         TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDCLOUDNETWORKBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpNetworkName.str().c_str(), (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDCLOUDNETWORKBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDCLOUDNETWORKBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNetwork=%p hrc=%Rhrc\n", this, "VirtualBox::findCloudNetworkByName", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::RemoveCloudNetwork(ICloudNetwork *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "VirtualBox::removeCloudNetwork", aNetwork));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<ICloudNetwork> TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVECLOUDNETWORK_ENTER(this, (void *)TmpNetwork.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeCloudNetwork(TmpNetwork.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVECLOUDNETWORK_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetwork.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVECLOUDNETWORK_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_REMOVECLOUDNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBox::removeCloudNetwork", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::CheckFirmwarePresent(PlatformArchitecture_T aPlatformArchitecture,
                                                  FirmwareType_T aFirmwareType,
                                                  IN_BSTR aVersion,
                                                  BSTR *aUrl,
                                                  BSTR *aFile,
                                                  BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aPlatformArchitecture=%RU32 aFirmwareType=%RU32 aVersion=%ls aUrl=%p aFile=%p aResult=%p\n", this, "VirtualBox::checkFirmwarePresent", aPlatformArchitecture, aFirmwareType, aVersion, aUrl, aFile, aResult));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUrl);
        CheckComArgOutPointerValidThrow(aFile);
        CheckComArgOutPointerValidThrow(aResult);


        
        
        BSTRInConverter TmpVersion(aVersion);
        BSTROutConverter TmpUrl(aUrl);
        BSTROutConverter TmpFile(aFile);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CHECKFIRMWAREPRESENT_ENTER(this, aPlatformArchitecture, aFirmwareType, TmpVersion.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkFirmwarePresent(aPlatformArchitecture,
                                       aFirmwareType,
                                       TmpVersion.str(),
                                       TmpUrl.str(),
                                       TmpFile.str(),
                                       aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CHECKFIRMWAREPRESENT_RETURN(this, hrc, 0 /*normal*/, aPlatformArchitecture, aFirmwareType, TmpVersion.str().c_str(), TmpUrl.str().c_str(), TmpFile.str().c_str(), *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CHECKFIRMWAREPRESENT_RETURN(this, hrc, 1 /*hrc exception*/, aPlatformArchitecture, aFirmwareType, 0, 0, 0, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_CHECKFIRMWAREPRESENT_RETURN(this, hrc, 9 /*unhandled exception*/, aPlatformArchitecture, aFirmwareType, 0, 0, 0, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUrl=%ls *aFile=%ls aResult=%RTbool hrc=%Rhrc\n", this, "VirtualBox::checkFirmwarePresent", !RT_VALID_PTR(aUrl) ? 0 : *aUrl, !RT_VALID_PTR(aFile) ? 0 : *aFile, !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::FindProgressById(IN_BSTR aId,
                                              IProgress **aProgressObject)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aProgressObject=%p\n", this, "VirtualBox::findProgressById", aId, aProgressObject));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgressObject);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IProgress> TmpProgressObject(aProgressObject);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDPROGRESSBYID_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findProgressById(TmpId.uuid(),
                                   TmpProgressObject.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDPROGRESSBYID_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpProgressObject.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDPROGRESSBYID_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_FINDPROGRESSBYID_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgressObject=%p hrc=%Rhrc\n", this, "VirtualBox::findProgressById", !RT_VALID_PTR(aProgressObject) ? 0 : *aProgressObject, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetTrackedObject(IN_BSTR aTrObjId,
                                              IUnknown **aPIface,
                                              TrackedObjectState_T *aState,
                                              LONG64 *aCreationTime,
                                              LONG64 *aDeletionTime)
{
    LogRelFlow(("{%p} %s: enter aTrObjId=%ls aPIface=%p aState=%p aCreationTime=%p aDeletionTime=%p\n", this, "VirtualBox::getTrackedObject", aTrObjId, aPIface, aState, aCreationTime, aDeletionTime));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPIface);
        CheckComArgOutPointerValidThrow(aState);
        CheckComArgOutPointerValidThrow(aCreationTime);
        CheckComArgOutPointerValidThrow(aDeletionTime);


        BSTRInConverter TmpTrObjId(aTrObjId);
        ComTypeOutConverter<IUnknown> TmpPIface(aPIface);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECT_ENTER(this, TmpTrObjId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTrackedObject(TmpTrObjId.str(),
                                   TmpPIface.ptr(),
                                   aState,
                                   aCreationTime,
                                   aDeletionTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECT_RETURN(this, hrc, 0 /*normal*/, TmpTrObjId.str().c_str(), (void *)TmpPIface.ptr(), *aState, *aCreationTime, *aDeletionTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, *aState, *aCreationTime, *aDeletionTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, *aState, *aCreationTime, *aDeletionTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPIface=%p *aState=%RU32 *aCreationTime=%RI64 *aDeletionTime=%RI64 hrc=%Rhrc\n", this, "VirtualBox::getTrackedObject", !RT_VALID_PTR(aPIface) ? 0 : *aPIface, !RT_VALID_PTR(aState) ? 0 : *aState, !RT_VALID_PTR(aCreationTime) ? 0 : *aCreationTime, !RT_VALID_PTR(aDeletionTime) ? 0 : *aDeletionTime, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::GetTrackedObjectIds(IN_BSTR aName,
                                                 ComSafeArrayOut(BSTR, aObjIdsList))
{
    LogRelFlow(("{%p} %s: enter aName=%ls aObjIdsList=%p\n", this, "VirtualBox::getTrackedObjectIds", aName, aObjIdsList));

    i_callHook(__FUNCTION__);
    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjIdsList);


        BSTRInConverter TmpName(aName);
        ArrayBSTROutConverter TmpObjIdsList(ComSafeArrayOutArg(aObjIdsList));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECTIDS_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTrackedObjectIds(TmpName.str(),
                                      TmpObjIdsList.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECTIDS_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (uint32_t)TmpObjIdsList.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECTIDS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOX_GETTRACKEDOBJECTIDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjIdsList=%zu hrc=%Rhrc\n", this, "VirtualBox::getTrackedObjectIds", !RT_VALID_PTR(aObjIdsList) ? 0 : ComSafeArraySize(*aObjIdsList), hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod1IVirtualBox()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod2IVirtualBox()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod3IVirtualBox()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod4IVirtualBox()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod5IVirtualBox()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxWrap::InternalAndReservedMethod6IVirtualBox()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VirtualBoxWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VirtualBoxWrap, IVirtualBox)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VirtualBoxWrap.cpp"


// ##### BEGINFILE "VFSExplorerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVFSExplorer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VFSEXPLORER

#include "VFSExplorerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VFSExplorerWrap)

//
// IVFSExplorer properties
//

STDMETHODIMP VFSExplorerWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "VFSExplorer::getPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPath);
        BSTROutConverter TmpPath(aPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_PATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPath=%ls hrc=%Rhrc\n", this, "VFSExplorer::getPath", !RT_VALID_PTR(aPath) ? 0 : *aPath, hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::COMGETTER(Type)(VFSType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "VFSExplorer::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "VFSExplorer::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}


//
// IVFSExplorer methods
//

STDMETHODIMP VFSExplorerWrap::Update(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "VFSExplorer::update", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_UPDATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = update(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_UPDATE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_UPDATE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_UPDATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "VFSExplorer::update", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::Cd(IN_BSTR aDir,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDir=%ls aProgress=%p\n", this, "VFSExplorer::cd", aDir, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpDir(aDir);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CD_ENTER(this, TmpDir.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cd(TmpDir.str(),
                     TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CD_RETURN(this, hrc, 0 /*normal*/, TmpDir.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CD_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "VFSExplorer::cd", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::CdUp(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "VFSExplorer::cdUp", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CDUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cdUp(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CDUP_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CDUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_CDUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "VFSExplorer::cdUp", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::EntryList(ComSafeArrayOut(BSTR, aNames),
                                        ComSafeArrayOut(ULONG, aTypes),
                                        ComSafeArrayOut(LONG64, aSizes),
                                        ComSafeArrayOut(ULONG, aModes))
{
    LogRelFlow(("{%p} %s: enter aNames=%p aTypes=%p aSizes=%p aModes=%p\n", this, "VFSExplorer::entryList", aNames, aTypes, aSizes, aModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNames);
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aSizes);
        CheckComArgOutPointerValidThrow(aModes);


        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayOutConverter<ULONG> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayOutConverter<LONG64> TmpSizes(ComSafeArrayOutArg(aSizes));
        ArrayOutConverter<ULONG> TmpModes(ComSafeArrayOutArg(aModes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_ENTRYLIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = entryList(TmpNames.array(),
                            TmpTypes.array(),
                            TmpSizes.array(),
                            TmpModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_ENTRYLIST_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpSizes.array().size(), NULL /*for now*/, (uint32_t)TmpModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_ENTRYLIST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_ENTRYLIST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aTypes=%zu *aSizes=%zu *aModes=%zu hrc=%Rhrc\n", this, "VFSExplorer::entryList", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aTypes) ? 0 : ComSafeArraySize(*aTypes), !RT_VALID_PTR(aSizes) ? 0 : ComSafeArraySize(*aSizes), !RT_VALID_PTR(aModes) ? 0 : ComSafeArraySize(*aModes), hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::Exists(ComSafeArrayIn(IN_BSTR, aNames),
                                     ComSafeArrayOut(BSTR, aExists))
{
    LogRelFlow(("{%p} %s: enter aNames=%zu aExists=%p\n", this, "VFSExplorer::exists", aNames, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        ArrayBSTRInConverter TmpNames(ComSafeArrayInArg(aNames));
        ArrayBSTROutConverter TmpExists(ComSafeArrayOutArg(aExists));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_EXISTS_ENTER(this, (uint32_t)TmpNames.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = exists(TmpNames.array(),
                         TmpExists.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_EXISTS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpExists.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_EXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_EXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%zu hrc=%Rhrc\n", this, "VFSExplorer::exists", !RT_VALID_PTR(aExists) ? 0 : ComSafeArraySize(*aExists), hrc));
    return hrc;
}

STDMETHODIMP VFSExplorerWrap::Remove(ComSafeArrayIn(IN_BSTR, aNames),
                                     IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aNames=%zu aProgress=%p\n", this, "VFSExplorer::remove", aNames, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpNames(ComSafeArrayInArg(aNames));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_REMOVE_ENTER(this, (uint32_t)TmpNames.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove(TmpNames.array(),
                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_REMOVE_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VFSEXPLORER_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "VFSExplorer::remove", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VFSExplorerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VFSExplorerWrap, IVFSExplorer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VFSExplorerWrap.cpp"


// ##### BEGINFILE "CertificateWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICertificate.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CERTIFICATE

#include "CertificateWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CertificateWrap)

//
// ICertificate properties
//

STDMETHODIMP CertificateWrap::COMGETTER(VersionNumber)(CertificateVersion_T *aVersionNumber)
{
    LogRelFlow(("{%p} %s: enter aVersionNumber=%p\n", this, "Certificate::getVersionNumber", aVersionNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersionNumber);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VERSIONNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersionNumber(aVersionNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VERSIONNUMBER_RETURN(this, hrc, 0 /*normal*/,*aVersionNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VERSIONNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aVersionNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VERSIONNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aVersionNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersionNumber=%RU32 hrc=%Rhrc\n", this, "Certificate::getVersionNumber", !RT_VALID_PTR(aVersionNumber) ? 0 : *aVersionNumber, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "Certificate::getSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialNumber);
        BSTROutConverter TmpSerialNumber(aSerialNumber);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%ls hrc=%Rhrc\n", this, "Certificate::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SignatureAlgorithmOID)(BSTR *aSignatureAlgorithmOID)
{
    LogRelFlow(("{%p} %s: enter aSignatureAlgorithmOID=%p\n", this, "Certificate::getSignatureAlgorithmOID", aSignatureAlgorithmOID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSignatureAlgorithmOID);
        BSTROutConverter TmpSignatureAlgorithmOID(aSignatureAlgorithmOID);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMOID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSignatureAlgorithmOID(TmpSignatureAlgorithmOID.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMOID_RETURN(this, hrc, 0 /*normal*/,TmpSignatureAlgorithmOID.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMOID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMOID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSignatureAlgorithmOID=%ls hrc=%Rhrc\n", this, "Certificate::getSignatureAlgorithmOID", !RT_VALID_PTR(aSignatureAlgorithmOID) ? 0 : *aSignatureAlgorithmOID, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SignatureAlgorithmName)(BSTR *aSignatureAlgorithmName)
{
    LogRelFlow(("{%p} %s: enter aSignatureAlgorithmName=%p\n", this, "Certificate::getSignatureAlgorithmName", aSignatureAlgorithmName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSignatureAlgorithmName);
        BSTROutConverter TmpSignatureAlgorithmName(aSignatureAlgorithmName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSignatureAlgorithmName(TmpSignatureAlgorithmName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMNAME_RETURN(this, hrc, 0 /*normal*/,TmpSignatureAlgorithmName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SIGNATUREALGORITHMNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSignatureAlgorithmName=%ls hrc=%Rhrc\n", this, "Certificate::getSignatureAlgorithmName", !RT_VALID_PTR(aSignatureAlgorithmName) ? 0 : *aSignatureAlgorithmName, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(IssuerName)(ComSafeArrayOut(BSTR, aIssuerName))
{
    LogRelFlow(("{%p} %s: enter aIssuerName=%p\n", this, "Certificate::getIssuerName", aIssuerName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIssuerName);
        ArrayBSTROutConverter TmpIssuerName(ComSafeArrayOutArg(aIssuerName));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIssuerName(TmpIssuerName.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERNAME_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpIssuerName.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERNAME_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIssuerName=%zu hrc=%Rhrc\n", this, "Certificate::getIssuerName", !RT_VALID_PTR(aIssuerName) ? 0 : ComSafeArraySize(*aIssuerName), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SubjectName)(ComSafeArrayOut(BSTR, aSubjectName))
{
    LogRelFlow(("{%p} %s: enter aSubjectName=%p\n", this, "Certificate::getSubjectName", aSubjectName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubjectName);
        ArrayBSTROutConverter TmpSubjectName(ComSafeArrayOutArg(aSubjectName));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubjectName(TmpSubjectName.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTNAME_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSubjectName.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTNAME_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubjectName=%zu hrc=%Rhrc\n", this, "Certificate::getSubjectName", !RT_VALID_PTR(aSubjectName) ? 0 : ComSafeArraySize(*aSubjectName), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(FriendlyName)(BSTR *aFriendlyName)
{
    LogRelFlow(("{%p} %s: enter aFriendlyName=%p\n", this, "Certificate::getFriendlyName", aFriendlyName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFriendlyName);
        BSTROutConverter TmpFriendlyName(aFriendlyName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_FRIENDLYNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFriendlyName(TmpFriendlyName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_FRIENDLYNAME_RETURN(this, hrc, 0 /*normal*/,TmpFriendlyName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_FRIENDLYNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_FRIENDLYNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFriendlyName=%ls hrc=%Rhrc\n", this, "Certificate::getFriendlyName", !RT_VALID_PTR(aFriendlyName) ? 0 : *aFriendlyName, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(ValidityPeriodNotBefore)(BSTR *aValidityPeriodNotBefore)
{
    LogRelFlow(("{%p} %s: enter aValidityPeriodNotBefore=%p\n", this, "Certificate::getValidityPeriodNotBefore", aValidityPeriodNotBefore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValidityPeriodNotBefore);
        BSTROutConverter TmpValidityPeriodNotBefore(aValidityPeriodNotBefore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTBEFORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValidityPeriodNotBefore(TmpValidityPeriodNotBefore.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTBEFORE_RETURN(this, hrc, 0 /*normal*/,TmpValidityPeriodNotBefore.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTBEFORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTBEFORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValidityPeriodNotBefore=%ls hrc=%Rhrc\n", this, "Certificate::getValidityPeriodNotBefore", !RT_VALID_PTR(aValidityPeriodNotBefore) ? 0 : *aValidityPeriodNotBefore, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(ValidityPeriodNotAfter)(BSTR *aValidityPeriodNotAfter)
{
    LogRelFlow(("{%p} %s: enter aValidityPeriodNotAfter=%p\n", this, "Certificate::getValidityPeriodNotAfter", aValidityPeriodNotAfter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValidityPeriodNotAfter);
        BSTROutConverter TmpValidityPeriodNotAfter(aValidityPeriodNotAfter);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTAFTER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValidityPeriodNotAfter(TmpValidityPeriodNotAfter.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTAFTER_RETURN(this, hrc, 0 /*normal*/,TmpValidityPeriodNotAfter.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTAFTER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_VALIDITYPERIODNOTAFTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValidityPeriodNotAfter=%ls hrc=%Rhrc\n", this, "Certificate::getValidityPeriodNotAfter", !RT_VALID_PTR(aValidityPeriodNotAfter) ? 0 : *aValidityPeriodNotAfter, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(PublicKeyAlgorithmOID)(BSTR *aPublicKeyAlgorithmOID)
{
    LogRelFlow(("{%p} %s: enter aPublicKeyAlgorithmOID=%p\n", this, "Certificate::getPublicKeyAlgorithmOID", aPublicKeyAlgorithmOID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPublicKeyAlgorithmOID);
        BSTROutConverter TmpPublicKeyAlgorithmOID(aPublicKeyAlgorithmOID);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHMOID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPublicKeyAlgorithmOID(TmpPublicKeyAlgorithmOID.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHMOID_RETURN(this, hrc, 0 /*normal*/,TmpPublicKeyAlgorithmOID.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHMOID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHMOID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPublicKeyAlgorithmOID=%ls hrc=%Rhrc\n", this, "Certificate::getPublicKeyAlgorithmOID", !RT_VALID_PTR(aPublicKeyAlgorithmOID) ? 0 : *aPublicKeyAlgorithmOID, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(PublicKeyAlgorithm)(BSTR *aPublicKeyAlgorithm)
{
    LogRelFlow(("{%p} %s: enter aPublicKeyAlgorithm=%p\n", this, "Certificate::getPublicKeyAlgorithm", aPublicKeyAlgorithm));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPublicKeyAlgorithm);
        BSTROutConverter TmpPublicKeyAlgorithm(aPublicKeyAlgorithm);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPublicKeyAlgorithm(TmpPublicKeyAlgorithm.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHM_RETURN(this, hrc, 0 /*normal*/,TmpPublicKeyAlgorithm.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_PUBLICKEYALGORITHM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPublicKeyAlgorithm=%ls hrc=%Rhrc\n", this, "Certificate::getPublicKeyAlgorithm", !RT_VALID_PTR(aPublicKeyAlgorithm) ? 0 : *aPublicKeyAlgorithm, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SubjectPublicKey)(ComSafeArrayOut(BYTE, aSubjectPublicKey))
{
    LogRelFlow(("{%p} %s: enter aSubjectPublicKey=%p\n", this, "Certificate::getSubjectPublicKey", aSubjectPublicKey));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubjectPublicKey);
        ArrayOutConverter<BYTE> TmpSubjectPublicKey(ComSafeArrayOutArg(aSubjectPublicKey));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubjectPublicKey(TmpSubjectPublicKey.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSubjectPublicKey.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubjectPublicKey=%zu hrc=%Rhrc\n", this, "Certificate::getSubjectPublicKey", !RT_VALID_PTR(aSubjectPublicKey) ? 0 : ComSafeArraySize(*aSubjectPublicKey), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(IssuerUniqueIdentifier)(BSTR *aIssuerUniqueIdentifier)
{
    LogRelFlow(("{%p} %s: enter aIssuerUniqueIdentifier=%p\n", this, "Certificate::getIssuerUniqueIdentifier", aIssuerUniqueIdentifier));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIssuerUniqueIdentifier);
        BSTROutConverter TmpIssuerUniqueIdentifier(aIssuerUniqueIdentifier);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIssuerUniqueIdentifier(TmpIssuerUniqueIdentifier.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 0 /*normal*/,TmpIssuerUniqueIdentifier.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIssuerUniqueIdentifier=%ls hrc=%Rhrc\n", this, "Certificate::getIssuerUniqueIdentifier", !RT_VALID_PTR(aIssuerUniqueIdentifier) ? 0 : *aIssuerUniqueIdentifier, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SubjectUniqueIdentifier)(BSTR *aSubjectUniqueIdentifier)
{
    LogRelFlow(("{%p} %s: enter aSubjectUniqueIdentifier=%p\n", this, "Certificate::getSubjectUniqueIdentifier", aSubjectUniqueIdentifier));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubjectUniqueIdentifier);
        BSTROutConverter TmpSubjectUniqueIdentifier(aSubjectUniqueIdentifier);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubjectUniqueIdentifier(TmpSubjectUniqueIdentifier.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 0 /*normal*/,TmpSubjectUniqueIdentifier.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubjectUniqueIdentifier=%ls hrc=%Rhrc\n", this, "Certificate::getSubjectUniqueIdentifier", !RT_VALID_PTR(aSubjectUniqueIdentifier) ? 0 : *aSubjectUniqueIdentifier, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(CertificateAuthority)(BOOL *aCertificateAuthority)
{
    LogRelFlow(("{%p} %s: enter aCertificateAuthority=%p\n", this, "Certificate::getCertificateAuthority", aCertificateAuthority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCertificateAuthority);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_CERTIFICATEAUTHORITY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCertificateAuthority(aCertificateAuthority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_CERTIFICATEAUTHORITY_RETURN(this, hrc, 0 /*normal*/,*aCertificateAuthority != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_CERTIFICATEAUTHORITY_RETURN(this, hrc, 1 /*hrc exception*/,*aCertificateAuthority != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_CERTIFICATEAUTHORITY_RETURN(this, hrc, 9 /*unhandled exception*/,*aCertificateAuthority != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCertificateAuthority=%RTbool hrc=%Rhrc\n", this, "Certificate::getCertificateAuthority", !RT_VALID_PTR(aCertificateAuthority) ? 0 : *aCertificateAuthority, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(KeyUsage)(ULONG *aKeyUsage)
{
    LogRelFlow(("{%p} %s: enter aKeyUsage=%p\n", this, "Certificate::getKeyUsage", aKeyUsage));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyUsage);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyUsage(aKeyUsage);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 0 /*normal*/,*aKeyUsage);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 1 /*hrc exception*/,*aKeyUsage);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 9 /*unhandled exception*/,*aKeyUsage);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyUsage=%RU32 hrc=%Rhrc\n", this, "Certificate::getKeyUsage", !RT_VALID_PTR(aKeyUsage) ? 0 : *aKeyUsage, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(ExtendedKeyUsage)(ComSafeArrayOut(BSTR, aExtendedKeyUsage))
{
    LogRelFlow(("{%p} %s: enter aExtendedKeyUsage=%p\n", this, "Certificate::getExtendedKeyUsage", aExtendedKeyUsage));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtendedKeyUsage);
        ArrayBSTROutConverter TmpExtendedKeyUsage(ComSafeArrayOutArg(aExtendedKeyUsage));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtendedKeyUsage(TmpExtendedKeyUsage.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpExtendedKeyUsage.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtendedKeyUsage=%zu hrc=%Rhrc\n", this, "Certificate::getExtendedKeyUsage", !RT_VALID_PTR(aExtendedKeyUsage) ? 0 : ComSafeArraySize(*aExtendedKeyUsage), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(RawCertData)(ComSafeArrayOut(BYTE, aRawCertData))
{
    LogRelFlow(("{%p} %s: enter aRawCertData=%p\n", this, "Certificate::getRawCertData", aRawCertData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRawCertData);
        ArrayOutConverter<BYTE> TmpRawCertData(ComSafeArrayOutArg(aRawCertData));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRawCertData(TmpRawCertData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpRawCertData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRawCertData=%zu hrc=%Rhrc\n", this, "Certificate::getRawCertData", !RT_VALID_PTR(aRawCertData) ? 0 : ComSafeArraySize(*aRawCertData), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SelfSigned)(BOOL *aSelfSigned)
{
    LogRelFlow(("{%p} %s: enter aSelfSigned=%p\n", this, "Certificate::getSelfSigned", aSelfSigned));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSelfSigned);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SELFSIGNED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSelfSigned(aSelfSigned);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SELFSIGNED_RETURN(this, hrc, 0 /*normal*/,*aSelfSigned != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SELFSIGNED_RETURN(this, hrc, 1 /*hrc exception*/,*aSelfSigned != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SELFSIGNED_RETURN(this, hrc, 9 /*unhandled exception*/,*aSelfSigned != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSelfSigned=%RTbool hrc=%Rhrc\n", this, "Certificate::getSelfSigned", !RT_VALID_PTR(aSelfSigned) ? 0 : *aSelfSigned, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(Trusted)(BOOL *aTrusted)
{
    LogRelFlow(("{%p} %s: enter aTrusted=%p\n", this, "Certificate::getTrusted", aTrusted));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTrusted);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_TRUSTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTrusted(aTrusted);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_TRUSTED_RETURN(this, hrc, 0 /*normal*/,*aTrusted != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_TRUSTED_RETURN(this, hrc, 1 /*hrc exception*/,*aTrusted != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_TRUSTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTrusted != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTrusted=%RTbool hrc=%Rhrc\n", this, "Certificate::getTrusted", !RT_VALID_PTR(aTrusted) ? 0 : *aTrusted, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(Expired)(BOOL *aExpired)
{
    LogRelFlow(("{%p} %s: enter aExpired=%p\n", this, "Certificate::getExpired", aExpired));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExpired);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXPIRED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExpired(aExpired);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXPIRED_RETURN(this, hrc, 0 /*normal*/,*aExpired != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXPIRED_RETURN(this, hrc, 1 /*hrc exception*/,*aExpired != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXPIRED_RETURN(this, hrc, 9 /*unhandled exception*/,*aExpired != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExpired=%RTbool hrc=%Rhrc\n", this, "Certificate::getExpired", !RT_VALID_PTR(aExpired) ? 0 : *aExpired, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute1ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute2ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute3ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute4ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute5ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute6ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute7ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute8ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute9ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute10ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute11ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute12ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICertificate methods
//

STDMETHODIMP CertificateWrap::IsCurrentlyExpired(BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "Certificate::isCurrentlyExpired", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isCurrentlyExpired(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "Certificate::isCurrentlyExpired", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::QueryInfo(LONG aWhat,
                                        BSTR *aResult)
{
    LogRelFlow(("{%p} %s: enter aWhat=%RI32 aResult=%p\n", this, "Certificate::queryInfo", aWhat, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        BSTROutConverter TmpResult(aResult);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_ENTER(this, aWhat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryInfo(aWhat,
                            TmpResult.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 0 /*normal*/, aWhat, TmpResult.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, aWhat, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, aWhat, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%ls hrc=%Rhrc\n", this, "Certificate::queryInfo", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::InternalAndReservedMethod1ICertificate()
{
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::InternalAndReservedMethod2ICertificate()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CertificateWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CertificateWrap, ICertificate)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CertificateWrap.cpp"


// ##### BEGINFILE "VirtualSystemDescriptionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVirtualSystemDescription.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALSYSTEMDESCRIPTION

#include "VirtualSystemDescriptionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescriptionWrap)

//
// IVirtualSystemDescription properties
//

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(Count)(ULONG *aCount)
{
    LogRelFlow(("{%p} %s: enter aCount=%p\n", this, "VirtualSystemDescription::getCount", aCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCount(aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 0 /*normal*/,*aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCount=%RU32 hrc=%Rhrc\n", this, "VirtualSystemDescription::getCount", !RT_VALID_PTR(aCount) ? 0 : *aCount, hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVirtualSystemDescription methods
//

STDMETHODIMP VirtualSystemDescriptionWrap::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                                                          ComSafeArrayOut(BSTR, aRefs),
                                                          ComSafeArrayOut(BSTR, aOVFValues),
                                                          ComSafeArrayOut(BSTR, aVBoxValues),
                                                          ComSafeArrayOut(BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s: enter aTypes=%p aRefs=%p aOVFValues=%p aVBoxValues=%p aExtraConfigValues=%p\n", this, "VirtualSystemDescription::getDescription", aTypes, aRefs, aOVFValues, aVBoxValues, aExtraConfigValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aRefs);
        CheckComArgOutPointerValidThrow(aOVFValues);
        CheckComArgOutPointerValidThrow(aVBoxValues);
        CheckComArgOutPointerValidThrow(aExtraConfigValues);


        ArrayOutConverter<VirtualSystemDescriptionType_T> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayBSTROutConverter TmpRefs(ComSafeArrayOutArg(aRefs));
        ArrayBSTROutConverter TmpOVFValues(ComSafeArrayOutArg(aOVFValues));
        ArrayBSTROutConverter TmpVBoxValues(ComSafeArrayOutArg(aVBoxValues));
        ArrayBSTROutConverter TmpExtraConfigValues(ComSafeArrayOutArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpTypes.array(),
                                 TmpRefs.array(),
                                 TmpOVFValues.array(),
                                 TmpVBoxValues.array(),
                                 TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpRefs.array().size(), NULL /*for now*/, (uint32_t)TmpOVFValues.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypes=%zu *aRefs=%zu *aOVFValues=%zu *aVBoxValues=%zu *aExtraConfigValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getDescription", !RT_VALID_PTR(aTypes) ? 0 : ComSafeArraySize(*aTypes), !RT_VALID_PTR(aRefs) ? 0 : ComSafeArraySize(*aRefs), !RT_VALID_PTR(aOVFValues) ? 0 : ComSafeArraySize(*aOVFValues), !RT_VALID_PTR(aVBoxValues) ? 0 : ComSafeArraySize(*aVBoxValues), !RT_VALID_PTR(aExtraConfigValues) ? 0 : ComSafeArraySize(*aExtraConfigValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::GetDescriptionByType(VirtualSystemDescriptionType_T aType,
                                                                ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                                                                ComSafeArrayOut(BSTR, aRefs),
                                                                ComSafeArrayOut(BSTR, aOVFValues),
                                                                ComSafeArrayOut(BSTR, aVBoxValues),
                                                                ComSafeArrayOut(BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aTypes=%p aRefs=%p aOVFValues=%p aVBoxValues=%p aExtraConfigValues=%p\n", this, "VirtualSystemDescription::getDescriptionByType", aType, aTypes, aRefs, aOVFValues, aVBoxValues, aExtraConfigValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aRefs);
        CheckComArgOutPointerValidThrow(aOVFValues);
        CheckComArgOutPointerValidThrow(aVBoxValues);
        CheckComArgOutPointerValidThrow(aExtraConfigValues);


        
        ArrayOutConverter<VirtualSystemDescriptionType_T> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayBSTROutConverter TmpRefs(ComSafeArrayOutArg(aRefs));
        ArrayBSTROutConverter TmpOVFValues(ComSafeArrayOutArg(aOVFValues));
        ArrayBSTROutConverter TmpVBoxValues(ComSafeArrayOutArg(aVBoxValues));
        ArrayBSTROutConverter TmpExtraConfigValues(ComSafeArrayOutArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescriptionByType(aType,
                                       TmpTypes.array(),
                                       TmpRefs.array(),
                                       TmpOVFValues.array(),
                                       TmpVBoxValues.array(),
                                       TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpRefs.array().size(), NULL /*for now*/, (uint32_t)TmpOVFValues.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypes=%zu *aRefs=%zu *aOVFValues=%zu *aVBoxValues=%zu *aExtraConfigValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getDescriptionByType", !RT_VALID_PTR(aTypes) ? 0 : ComSafeArraySize(*aTypes), !RT_VALID_PTR(aRefs) ? 0 : ComSafeArraySize(*aRefs), !RT_VALID_PTR(aOVFValues) ? 0 : ComSafeArraySize(*aOVFValues), !RT_VALID_PTR(aVBoxValues) ? 0 : ComSafeArraySize(*aVBoxValues), !RT_VALID_PTR(aExtraConfigValues) ? 0 : ComSafeArraySize(*aExtraConfigValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::RemoveDescriptionByType(VirtualSystemDescriptionType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "VirtualSystemDescription::removeDescriptionByType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_REMOVEDESCRIPTIONBYTYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeDescriptionByType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_REMOVEDESCRIPTIONBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_REMOVEDESCRIPTIONBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_REMOVEDESCRIPTIONBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualSystemDescription::removeDescriptionByType", hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::GetValuesByType(VirtualSystemDescriptionType_T aType,
                                                           VirtualSystemDescriptionValueType_T aWhich,
                                                           ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aWhich=%RU32 aValues=%p\n", this, "VirtualSystemDescription::getValuesByType", aType, aWhich, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);


        
        
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_ENTER(this, aType, aWhich);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValuesByType(aType,
                                  aWhich,
                                  TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType, aWhich, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType, aWhich, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, aWhich, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getValuesByType", !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
                                                          ComSafeArrayIn(IN_BSTR, aVBoxValues),
                                                          ComSafeArrayIn(IN_BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s: enter aEnabled=%zu aVBoxValues=%zu aExtraConfigValues=%zu\n", this, "VirtualSystemDescription::setFinalValues", aEnabled, aVBoxValues, aExtraConfigValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayInConverter<BOOL> TmpEnabled(ComSafeArrayInArg(aEnabled));
        ArrayBSTRInConverter TmpVBoxValues(ComSafeArrayInArg(aVBoxValues));
        ArrayBSTRInConverter TmpExtraConfigValues(ComSafeArrayInArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_ENTER(this, (uint32_t)TmpEnabled.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFinalValues(TmpEnabled.array(),
                                 TmpVBoxValues.array(),
                                 TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpEnabled.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualSystemDescription::setFinalValues", hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::AddDescription(VirtualSystemDescriptionType_T aType,
                                                          IN_BSTR aVBoxValue,
                                                          IN_BSTR aExtraConfigValue)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aVBoxValue=%ls aExtraConfigValue=%ls\n", this, "VirtualSystemDescription::addDescription", aType, aVBoxValue, aExtraConfigValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        BSTRInConverter TmpVBoxValue(aVBoxValue);
        BSTRInConverter TmpExtraConfigValue(aExtraConfigValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_ENTER(this, aType, TmpVBoxValue.str().c_str(), TmpExtraConfigValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addDescription(aType,
                                 TmpVBoxValue.str(),
                                 TmpExtraConfigValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, aType, TmpVBoxValue.str().c_str(), TmpExtraConfigValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualSystemDescription::addDescription", hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod1IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod2IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod3IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod4IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VirtualSystemDescriptionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VirtualSystemDescriptionWrap, IVirtualSystemDescription)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VirtualSystemDescriptionWrap.cpp"


// ##### BEGINFILE "FirmwareSettingsWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFirmwareSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_FIRMWARESETTINGS

#include "FirmwareSettingsWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FirmwareSettingsWrap)

//
// IFirmwareSettings properties
//

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(FirmwareType)(FirmwareType_T *aFirmwareType)
{
    LogRelFlow(("{%p} %s: enter aFirmwareType=%p\n", this, "FirmwareSettings::getFirmwareType", aFirmwareType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFirmwareType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_FIRMWARETYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFirmwareType(aFirmwareType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_FIRMWARETYPE_RETURN(this, hrc, 0 /*normal*/,*aFirmwareType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_FIRMWARETYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aFirmwareType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_FIRMWARETYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aFirmwareType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFirmwareType=%RU32 hrc=%Rhrc\n", this, "FirmwareSettings::getFirmwareType", !RT_VALID_PTR(aFirmwareType) ? 0 : *aFirmwareType, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(FirmwareType)(FirmwareType_T aFirmwareType)
{
    LogRelFlow(("{%p} %s: enter aFirmwareType=%RU32\n", this, "FirmwareSettings::setFirmwareType", aFirmwareType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_FIRMWARETYPE_ENTER(this, aFirmwareType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFirmwareType(aFirmwareType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_FIRMWARETYPE_RETURN(this, hrc, 0 /*normal*/,aFirmwareType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_FIRMWARETYPE_RETURN(this, hrc, 1 /*hrc exception*/,aFirmwareType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_FIRMWARETYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aFirmwareType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setFirmwareType", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(LogoFadeIn)(BOOL *aLogoFadeIn)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeIn=%p\n", this, "FirmwareSettings::getLogoFadeIn", aLogoFadeIn));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoFadeIn);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoFadeIn(aLogoFadeIn);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEIN_RETURN(this, hrc, 0 /*normal*/,*aLogoFadeIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEIN_RETURN(this, hrc, 1 /*hrc exception*/,*aLogoFadeIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogoFadeIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoFadeIn=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getLogoFadeIn", !RT_VALID_PTR(aLogoFadeIn) ? 0 : *aLogoFadeIn, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(LogoFadeIn)(BOOL aLogoFadeIn)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeIn=%RTbool\n", this, "FirmwareSettings::setLogoFadeIn", aLogoFadeIn));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEIN_ENTER(this, aLogoFadeIn != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoFadeIn(aLogoFadeIn != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 0 /*normal*/,aLogoFadeIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 1 /*hrc exception*/,aLogoFadeIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 9 /*unhandled exception*/,aLogoFadeIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setLogoFadeIn", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(LogoFadeOut)(BOOL *aLogoFadeOut)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeOut=%p\n", this, "FirmwareSettings::getLogoFadeOut", aLogoFadeOut));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoFadeOut);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoFadeOut(aLogoFadeOut);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEOUT_RETURN(this, hrc, 0 /*normal*/,*aLogoFadeOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aLogoFadeOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOFADEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogoFadeOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoFadeOut=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getLogoFadeOut", !RT_VALID_PTR(aLogoFadeOut) ? 0 : *aLogoFadeOut, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(LogoFadeOut)(BOOL aLogoFadeOut)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeOut=%RTbool\n", this, "FirmwareSettings::setLogoFadeOut", aLogoFadeOut));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEOUT_ENTER(this, aLogoFadeOut != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoFadeOut(aLogoFadeOut != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 0 /*normal*/,aLogoFadeOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aLogoFadeOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aLogoFadeOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setLogoFadeOut", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(LogoDisplayTime)(ULONG *aLogoDisplayTime)
{
    LogRelFlow(("{%p} %s: enter aLogoDisplayTime=%p\n", this, "FirmwareSettings::getLogoDisplayTime", aLogoDisplayTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoDisplayTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGODISPLAYTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoDisplayTime(aLogoDisplayTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 0 /*normal*/,*aLogoDisplayTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aLogoDisplayTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogoDisplayTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoDisplayTime=%RU32 hrc=%Rhrc\n", this, "FirmwareSettings::getLogoDisplayTime", !RT_VALID_PTR(aLogoDisplayTime) ? 0 : *aLogoDisplayTime, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(LogoDisplayTime)(ULONG aLogoDisplayTime)
{
    LogRelFlow(("{%p} %s: enter aLogoDisplayTime=%RU32\n", this, "FirmwareSettings::setLogoDisplayTime", aLogoDisplayTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGODISPLAYTIME_ENTER(this, aLogoDisplayTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoDisplayTime(aLogoDisplayTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGODISPLAYTIME_RETURN(this, hrc, 0 /*normal*/,aLogoDisplayTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGODISPLAYTIME_RETURN(this, hrc, 1 /*hrc exception*/,aLogoDisplayTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGODISPLAYTIME_RETURN(this, hrc, 9 /*unhandled exception*/,aLogoDisplayTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setLogoDisplayTime", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(LogoImagePath)(BSTR *aLogoImagePath)
{
    LogRelFlow(("{%p} %s: enter aLogoImagePath=%p\n", this, "FirmwareSettings::getLogoImagePath", aLogoImagePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoImagePath);
        BSTROutConverter TmpLogoImagePath(aLogoImagePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOIMAGEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoImagePath(TmpLogoImagePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 0 /*normal*/,TmpLogoImagePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoImagePath=%ls hrc=%Rhrc\n", this, "FirmwareSettings::getLogoImagePath", !RT_VALID_PTR(aLogoImagePath) ? 0 : *aLogoImagePath, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(LogoImagePath)(IN_BSTR aLogoImagePath)
{
    LogRelFlow(("{%p} %s: enter aLogoImagePath=%ls\n", this, "FirmwareSettings::setLogoImagePath", aLogoImagePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpLogoImagePath(aLogoImagePath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOIMAGEPATH_ENTER(this, TmpLogoImagePath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoImagePath(TmpLogoImagePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 0 /*normal*/,TmpLogoImagePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setLogoImagePath", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(BootMenuMode)(FirmwareBootMenuMode_T *aBootMenuMode)
{
    LogRelFlow(("{%p} %s: enter aBootMenuMode=%p\n", this, "FirmwareSettings::getBootMenuMode", aBootMenuMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBootMenuMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_BOOTMENUMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootMenuMode(aBootMenuMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 0 /*normal*/,*aBootMenuMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aBootMenuMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBootMenuMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBootMenuMode=%RU32 hrc=%Rhrc\n", this, "FirmwareSettings::getBootMenuMode", !RT_VALID_PTR(aBootMenuMode) ? 0 : *aBootMenuMode, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(BootMenuMode)(FirmwareBootMenuMode_T aBootMenuMode)
{
    LogRelFlow(("{%p} %s: enter aBootMenuMode=%RU32\n", this, "FirmwareSettings::setBootMenuMode", aBootMenuMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_BOOTMENUMODE_ENTER(this, aBootMenuMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBootMenuMode(aBootMenuMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_BOOTMENUMODE_RETURN(this, hrc, 0 /*normal*/,aBootMenuMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_BOOTMENUMODE_RETURN(this, hrc, 1 /*hrc exception*/,aBootMenuMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_BOOTMENUMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aBootMenuMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setBootMenuMode", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(ACPIEnabled)(BOOL *aACPIEnabled)
{
    LogRelFlow(("{%p} %s: enter aACPIEnabled=%p\n", this, "FirmwareSettings::getACPIEnabled", aACPIEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aACPIEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_ACPIENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getACPIEnabled(aACPIEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_ACPIENABLED_RETURN(this, hrc, 0 /*normal*/,*aACPIEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_ACPIENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aACPIEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_ACPIENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aACPIEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aACPIEnabled=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getACPIEnabled", !RT_VALID_PTR(aACPIEnabled) ? 0 : *aACPIEnabled, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(ACPIEnabled)(BOOL aACPIEnabled)
{
    LogRelFlow(("{%p} %s: enter aACPIEnabled=%RTbool\n", this, "FirmwareSettings::setACPIEnabled", aACPIEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_ACPIENABLED_ENTER(this, aACPIEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setACPIEnabled(aACPIEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 0 /*normal*/,aACPIEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aACPIEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aACPIEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setACPIEnabled", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(IOAPICEnabled)(BOOL *aIOAPICEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOAPICEnabled=%p\n", this, "FirmwareSettings::getIOAPICEnabled", aIOAPICEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIOAPICEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_IOAPICENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOAPICEnabled(aIOAPICEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_IOAPICENABLED_RETURN(this, hrc, 0 /*normal*/,*aIOAPICEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_IOAPICENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aIOAPICEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_IOAPICENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOAPICEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOAPICEnabled=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getIOAPICEnabled", !RT_VALID_PTR(aIOAPICEnabled) ? 0 : *aIOAPICEnabled, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(IOAPICEnabled)(BOOL aIOAPICEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOAPICEnabled=%RTbool\n", this, "FirmwareSettings::setIOAPICEnabled", aIOAPICEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_IOAPICENABLED_ENTER(this, aIOAPICEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOAPICEnabled(aIOAPICEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 0 /*normal*/,aIOAPICEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aIOAPICEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aIOAPICEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setIOAPICEnabled", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(APICMode)(APICMode_T *aAPICMode)
{
    LogRelFlow(("{%p} %s: enter aAPICMode=%p\n", this, "FirmwareSettings::getAPICMode", aAPICMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAPICMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_APICMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAPICMode(aAPICMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_APICMODE_RETURN(this, hrc, 0 /*normal*/,*aAPICMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_APICMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAPICMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_APICMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAPICMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAPICMode=%RU32 hrc=%Rhrc\n", this, "FirmwareSettings::getAPICMode", !RT_VALID_PTR(aAPICMode) ? 0 : *aAPICMode, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(APICMode)(APICMode_T aAPICMode)
{
    LogRelFlow(("{%p} %s: enter aAPICMode=%RU32\n", this, "FirmwareSettings::setAPICMode", aAPICMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_APICMODE_ENTER(this, aAPICMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAPICMode(aAPICMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_APICMODE_RETURN(this, hrc, 0 /*normal*/,aAPICMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_APICMODE_RETURN(this, hrc, 1 /*hrc exception*/,aAPICMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_APICMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aAPICMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setAPICMode", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(TimeOffset)(LONG64 *aTimeOffset)
{
    LogRelFlow(("{%p} %s: enter aTimeOffset=%p\n", this, "FirmwareSettings::getTimeOffset", aTimeOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeOffset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_TIMEOFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeOffset(aTimeOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 0 /*normal*/,*aTimeOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeOffset=%RI64 hrc=%Rhrc\n", this, "FirmwareSettings::getTimeOffset", !RT_VALID_PTR(aTimeOffset) ? 0 : *aTimeOffset, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(TimeOffset)(LONG64 aTimeOffset)
{
    LogRelFlow(("{%p} %s: enter aTimeOffset=%RI64\n", this, "FirmwareSettings::setTimeOffset", aTimeOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_TIMEOFFSET_ENTER(this, aTimeOffset);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTimeOffset(aTimeOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_TIMEOFFSET_RETURN(this, hrc, 0 /*normal*/,aTimeOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_TIMEOFFSET_RETURN(this, hrc, 1 /*hrc exception*/,aTimeOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_TIMEOFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,aTimeOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setTimeOffset", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(PXEDebugEnabled)(BOOL *aPXEDebugEnabled)
{
    LogRelFlow(("{%p} %s: enter aPXEDebugEnabled=%p\n", this, "FirmwareSettings::getPXEDebugEnabled", aPXEDebugEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPXEDebugEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_PXEDEBUGENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPXEDebugEnabled(aPXEDebugEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_PXEDEBUGENABLED_RETURN(this, hrc, 0 /*normal*/,*aPXEDebugEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_PXEDEBUGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aPXEDebugEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_PXEDEBUGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aPXEDebugEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPXEDebugEnabled=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getPXEDebugEnabled", !RT_VALID_PTR(aPXEDebugEnabled) ? 0 : *aPXEDebugEnabled, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(PXEDebugEnabled)(BOOL aPXEDebugEnabled)
{
    LogRelFlow(("{%p} %s: enter aPXEDebugEnabled=%RTbool\n", this, "FirmwareSettings::setPXEDebugEnabled", aPXEDebugEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_PXEDEBUGENABLED_ENTER(this, aPXEDebugEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPXEDebugEnabled(aPXEDebugEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 0 /*normal*/,aPXEDebugEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aPXEDebugEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aPXEDebugEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setPXEDebugEnabled", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(SMBIOSUuidLittleEndian)(BOOL *aSMBIOSUuidLittleEndian)
{
    LogRelFlow(("{%p} %s: enter aSMBIOSUuidLittleEndian=%p\n", this, "FirmwareSettings::getSMBIOSUuidLittleEndian", aSMBIOSUuidLittleEndian));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSMBIOSUuidLittleEndian);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_SMBIOSUUIDLITTLEENDIAN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSMBIOSUuidLittleEndian(aSMBIOSUuidLittleEndian);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 0 /*normal*/,*aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 1 /*hrc exception*/,*aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 9 /*unhandled exception*/,*aSMBIOSUuidLittleEndian != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSMBIOSUuidLittleEndian=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getSMBIOSUuidLittleEndian", !RT_VALID_PTR(aSMBIOSUuidLittleEndian) ? 0 : *aSMBIOSUuidLittleEndian, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(SMBIOSUuidLittleEndian)(BOOL aSMBIOSUuidLittleEndian)
{
    LogRelFlow(("{%p} %s: enter aSMBIOSUuidLittleEndian=%RTbool\n", this, "FirmwareSettings::setSMBIOSUuidLittleEndian", aSMBIOSUuidLittleEndian));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_ENTER(this, aSMBIOSUuidLittleEndian != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSMBIOSUuidLittleEndian(aSMBIOSUuidLittleEndian != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 0 /*normal*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 1 /*hrc exception*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 9 /*unhandled exception*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setSMBIOSUuidLittleEndian", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(AutoSerialNumGen)(BOOL *aAutoSerialNumGen)
{
    LogRelFlow(("{%p} %s: enter aAutoSerialNumGen=%p\n", this, "FirmwareSettings::getAutoSerialNumGen", aAutoSerialNumGen));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutoSerialNumGen);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_AUTOSERIALNUMGEN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutoSerialNumGen(aAutoSerialNumGen);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_AUTOSERIALNUMGEN_RETURN(this, hrc, 0 /*normal*/,*aAutoSerialNumGen != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_AUTOSERIALNUMGEN_RETURN(this, hrc, 1 /*hrc exception*/,*aAutoSerialNumGen != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_GET_AUTOSERIALNUMGEN_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutoSerialNumGen != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutoSerialNumGen=%RTbool hrc=%Rhrc\n", this, "FirmwareSettings::getAutoSerialNumGen", !RT_VALID_PTR(aAutoSerialNumGen) ? 0 : *aAutoSerialNumGen, hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMSETTER(AutoSerialNumGen)(BOOL aAutoSerialNumGen)
{
    LogRelFlow(("{%p} %s: enter aAutoSerialNumGen=%RTbool\n", this, "FirmwareSettings::setAutoSerialNumGen", aAutoSerialNumGen));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_AUTOSERIALNUMGEN_ENTER(this, aAutoSerialNumGen != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutoSerialNumGen(aAutoSerialNumGen != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_AUTOSERIALNUMGEN_RETURN(this, hrc, 0 /*normal*/,aAutoSerialNumGen != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_AUTOSERIALNUMGEN_RETURN(this, hrc, 1 /*hrc exception*/,aAutoSerialNumGen != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FIRMWARESETTINGS_SET_AUTOSERIALNUMGEN_RETURN(this, hrc, 9 /*unhandled exception*/,aAutoSerialNumGen != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FirmwareSettings::setAutoSerialNumGen", hrc));
    return hrc;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute1IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute2IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute3IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute4IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute5IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute6IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute7IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::COMGETTER(InternalAndReservedAttribute8IFirmwareSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFirmwareSettings methods
//

STDMETHODIMP FirmwareSettingsWrap::InternalAndReservedMethod1IFirmwareSettings()
{
    return E_NOTIMPL;
}

STDMETHODIMP FirmwareSettingsWrap::InternalAndReservedMethod2IFirmwareSettings()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FirmwareSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FirmwareSettingsWrap, IFirmwareSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FirmwareSettingsWrap.cpp"


// ##### BEGINFILE "TrustedPlatformModuleWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ITrustedPlatformModule.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_TRUSTEDPLATFORMMODULE

#include "TrustedPlatformModuleWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(TrustedPlatformModuleWrap)

//
// ITrustedPlatformModule properties
//

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(Type)(TpmType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "TrustedPlatformModule::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "TrustedPlatformModule::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMSETTER(Type)(TpmType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "TrustedPlatformModule::setType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_TYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_TYPE_RETURN(this, hrc, 0 /*normal*/,aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "TrustedPlatformModule::setType", hrc));
    return hrc;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(Location)(BSTR *aLocation)
{
    LogRelFlow(("{%p} %s: enter aLocation=%p\n", this, "TrustedPlatformModule::getLocation", aLocation));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLocation);
        BSTROutConverter TmpLocation(aLocation);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_LOCATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLocation(TmpLocation.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_LOCATION_RETURN(this, hrc, 0 /*normal*/,TmpLocation.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_LOCATION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_GET_LOCATION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLocation=%ls hrc=%Rhrc\n", this, "TrustedPlatformModule::getLocation", !RT_VALID_PTR(aLocation) ? 0 : *aLocation, hrc));
    return hrc;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMSETTER(Location)(IN_BSTR aLocation)
{
    LogRelFlow(("{%p} %s: enter aLocation=%ls\n", this, "TrustedPlatformModule::setLocation", aLocation));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpLocation(aLocation);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_LOCATION_ENTER(this, TmpLocation.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLocation(TmpLocation.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_LOCATION_RETURN(this, hrc, 0 /*normal*/,TmpLocation.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_LOCATION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TRUSTEDPLATFORMMODULE_SET_LOCATION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "TrustedPlatformModule::setLocation", hrc));
    return hrc;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute1ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute2ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute3ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute4ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute5ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute6ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute7ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::COMGETTER(InternalAndReservedAttribute8ITrustedPlatformModule)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ITrustedPlatformModule methods
//

STDMETHODIMP TrustedPlatformModuleWrap::InternalAndReservedMethod1ITrustedPlatformModule()
{
    return E_NOTIMPL;
}

STDMETHODIMP TrustedPlatformModuleWrap::InternalAndReservedMethod2ITrustedPlatformModule()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(TrustedPlatformModuleWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(TrustedPlatformModuleWrap, ITrustedPlatformModule)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "TrustedPlatformModuleWrap.cpp"


// ##### BEGINFILE "RecordingSettingsWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IRecordingSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_RECORDINGSETTINGS

#include "RecordingSettingsWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(RecordingSettingsWrap)

//
// IRecordingSettings properties
//

STDMETHODIMP RecordingSettingsWrap::COMGETTER(Paused)(BOOL *aPaused)
{
    LogRelFlow(("{%p} %s: enter aPaused=%p\n", this, "RecordingSettings::getPaused", aPaused));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPaused);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PAUSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPaused(aPaused);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PAUSED_RETURN(this, hrc, 0 /*normal*/,*aPaused != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PAUSED_RETURN(this, hrc, 1 /*hrc exception*/,*aPaused != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PAUSED_RETURN(this, hrc, 9 /*unhandled exception*/,*aPaused != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPaused=%RTbool hrc=%Rhrc\n", this, "RecordingSettings::getPaused", !RT_VALID_PTR(aPaused) ? 0 : *aPaused, hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::COMSETTER(Paused)(BOOL aPaused)
{
    LogRelFlow(("{%p} %s: enter aPaused=%RTbool\n", this, "RecordingSettings::setPaused", aPaused));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_PAUSED_ENTER(this, aPaused != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPaused(aPaused != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_PAUSED_RETURN(this, hrc, 0 /*normal*/,aPaused != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_PAUSED_RETURN(this, hrc, 1 /*hrc exception*/,aPaused != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_PAUSED_RETURN(this, hrc, 9 /*unhandled exception*/,aPaused != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "RecordingSettings::setPaused", hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "RecordingSettings::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "RecordingSettings::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "RecordingSettings::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "RecordingSettings::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::COMGETTER(Screens)(ComSafeArrayOut(IRecordingScreenSettings *, aScreens))
{
    LogRelFlow(("{%p} %s: enter aScreens=%p\n", this, "RecordingSettings::getScreens", aScreens));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreens);
        ArrayComTypeOutConverter<IRecordingScreenSettings> TmpScreens(ComSafeArrayOutArg(aScreens));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreens(TmpScreens.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpScreens.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreens=%zu hrc=%Rhrc\n", this, "RecordingSettings::getScreens", !RT_VALID_PTR(aScreens) ? 0 : ComSafeArraySize(*aScreens), hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::COMGETTER(Progress)(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "RecordingSettings::getProgress", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PROGRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProgress(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PROGRESS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PROGRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_PROGRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProgress=%p hrc=%Rhrc\n", this, "RecordingSettings::getProgress", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}


//
// IRecordingSettings methods
//

STDMETHODIMP RecordingSettingsWrap::GetScreenSettings(ULONG aScreenId,
                                                      IRecordingScreenSettings **aRecordScreenSettings)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aRecordScreenSettings=%p\n", this, "RecordingSettings::getScreenSettings", aScreenId, aRecordScreenSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecordScreenSettings);


        
        ComTypeOutConverter<IRecordingScreenSettings> TmpRecordScreenSettings(aRecordScreenSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenSettings(aScreenId,
                                    TmpRecordScreenSettings.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 0 /*normal*/, aScreenId, (void *)TmpRecordScreenSettings.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aRecordScreenSettings=%p hrc=%Rhrc\n", this, "RecordingSettings::getScreenSettings", !RT_VALID_PTR(aRecordScreenSettings) ? 0 : *aRecordScreenSettings, hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::Start(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "RecordingSettings::start", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_START_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = start(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_START_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_START_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_START_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "RecordingSettings::start", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP RecordingSettingsWrap::Resume()
{
    LogRelFlow(("{%p} %s: enter\n", this, "RecordingSettings::resume"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_RESUME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resume();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_RESUME_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_RESUME_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_RESUME_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "RecordingSettings::resume", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(RecordingSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(RecordingSettingsWrap, IRecordingSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "RecordingSettingsWrap.cpp"


// ##### BEGINFILE "PCIDeviceAttachmentWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPCIDeviceAttachment.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PCIDEVICEATTACHMENT

#include "PCIDeviceAttachmentWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PCIDeviceAttachmentWrap)

//
// IPCIDeviceAttachment properties
//

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "PCIDeviceAttachment::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "PCIDeviceAttachment::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(IsPhysicalDevice)(BOOL *aIsPhysicalDevice)
{
    LogRelFlow(("{%p} %s: enter aIsPhysicalDevice=%p\n", this, "PCIDeviceAttachment::getIsPhysicalDevice", aIsPhysicalDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsPhysicalDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_ISPHYSICALDEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsPhysicalDevice(aIsPhysicalDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_ISPHYSICALDEVICE_RETURN(this, hrc, 0 /*normal*/,*aIsPhysicalDevice != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_ISPHYSICALDEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aIsPhysicalDevice != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_ISPHYSICALDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsPhysicalDevice != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsPhysicalDevice=%RTbool hrc=%Rhrc\n", this, "PCIDeviceAttachment::getIsPhysicalDevice", !RT_VALID_PTR(aIsPhysicalDevice) ? 0 : *aIsPhysicalDevice, hrc));
    return hrc;
}

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(HostAddress)(LONG *aHostAddress)
{
    LogRelFlow(("{%p} %s: enter aHostAddress=%p\n", this, "PCIDeviceAttachment::getHostAddress", aHostAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostAddress);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostAddress(aHostAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 0 /*normal*/,*aHostAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,*aHostAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,*aHostAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostAddress=%RI32 hrc=%Rhrc\n", this, "PCIDeviceAttachment::getHostAddress", !RT_VALID_PTR(aHostAddress) ? 0 : *aHostAddress, hrc));
    return hrc;
}

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(GuestAddress)(LONG *aGuestAddress)
{
    LogRelFlow(("{%p} %s: enter aGuestAddress=%p\n", this, "PCIDeviceAttachment::getGuestAddress", aGuestAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestAddress);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestAddress(aGuestAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 0 /*normal*/,*aGuestAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,*aGuestAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,*aGuestAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestAddress=%RI32 hrc=%Rhrc\n", this, "PCIDeviceAttachment::getGuestAddress", !RT_VALID_PTR(aGuestAddress) ? 0 : *aGuestAddress, hrc));
    return hrc;
}


//
// IPCIDeviceAttachment methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PCIDeviceAttachmentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PCIDeviceAttachmentWrap, IPCIDeviceAttachment)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PCIDeviceAttachmentWrap.cpp"


// ##### BEGINFILE "NvramStoreWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for INvramStore.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_NVRAMSTORE

#include "NvramStoreWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(NvramStoreWrap)

//
// INvramStore properties
//

STDMETHODIMP NvramStoreWrap::COMGETTER(NonVolatileStorageFile)(BSTR *aNonVolatileStorageFile)
{
    LogRelFlow(("{%p} %s: enter aNonVolatileStorageFile=%p\n", this, "NvramStore::getNonVolatileStorageFile", aNonVolatileStorageFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNonVolatileStorageFile);
        BSTROutConverter TmpNonVolatileStorageFile(aNonVolatileStorageFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_NONVOLATILESTORAGEFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNonVolatileStorageFile(TmpNonVolatileStorageFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 0 /*normal*/,TmpNonVolatileStorageFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNonVolatileStorageFile=%ls hrc=%Rhrc\n", this, "NvramStore::getNonVolatileStorageFile", !RT_VALID_PTR(aNonVolatileStorageFile) ? 0 : *aNonVolatileStorageFile, hrc));
    return hrc;
}

STDMETHODIMP NvramStoreWrap::COMGETTER(UefiVariableStore)(IUefiVariableStore **aUefiVariableStore)
{
    LogRelFlow(("{%p} %s: enter aUefiVariableStore=%p\n", this, "NvramStore::getUefiVariableStore", aUefiVariableStore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUefiVariableStore);
        ComTypeOutConverter<IUefiVariableStore> TmpUefiVariableStore(aUefiVariableStore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_UEFIVARIABLESTORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUefiVariableStore(TmpUefiVariableStore.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_UEFIVARIABLESTORE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpUefiVariableStore.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_UEFIVARIABLESTORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_UEFIVARIABLESTORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUefiVariableStore=%p hrc=%Rhrc\n", this, "NvramStore::getUefiVariableStore", !RT_VALID_PTR(aUefiVariableStore) ? 0 : *aUefiVariableStore, hrc));
    return hrc;
}

STDMETHODIMP NvramStoreWrap::COMGETTER(KeyId)(BSTR *aKeyId)
{
    LogRelFlow(("{%p} %s: enter aKeyId=%p\n", this, "NvramStore::getKeyId", aKeyId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyId);
        BSTROutConverter TmpKeyId(aKeyId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyId(TmpKeyId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYID_RETURN(this, hrc, 0 /*normal*/,TmpKeyId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyId=%ls hrc=%Rhrc\n", this, "NvramStore::getKeyId", !RT_VALID_PTR(aKeyId) ? 0 : *aKeyId, hrc));
    return hrc;
}

STDMETHODIMP NvramStoreWrap::COMGETTER(KeyStore)(BSTR *aKeyStore)
{
    LogRelFlow(("{%p} %s: enter aKeyStore=%p\n", this, "NvramStore::getKeyStore", aKeyStore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyStore);
        BSTROutConverter TmpKeyStore(aKeyStore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYSTORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyStore(TmpKeyStore.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYSTORE_RETURN(this, hrc, 0 /*normal*/,TmpKeyStore.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYSTORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_GET_KEYSTORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyStore=%ls hrc=%Rhrc\n", this, "NvramStore::getKeyStore", !RT_VALID_PTR(aKeyStore) ? 0 : *aKeyStore, hrc));
    return hrc;
}


//
// INvramStore methods
//

STDMETHODIMP NvramStoreWrap::InitUefiVariableStore(ULONG aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%RU32\n", this, "NvramStore::initUefiVariableStore", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_INITUEFIVARIABLESTORE_ENTER(this, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = initUefiVariableStore(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_INITUEFIVARIABLESTORE_RETURN(this, hrc, 0 /*normal*/, aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_INITUEFIVARIABLESTORE_RETURN(this, hrc, 1 /*hrc exception*/, aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NVRAMSTORE_INITUEFIVARIABLESTORE_RETURN(this, hrc, 9 /*unhandled exception*/, aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NvramStore::initUefiVariableStore", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(NvramStoreWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NvramStoreWrap, INvramStore)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "NvramStoreWrap.cpp"


// ##### BEGINFILE "PlatformWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPlatform.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PLATFORM

#include "PlatformWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PlatformWrap)

//
// IPlatform properties
//

STDMETHODIMP PlatformWrap::COMGETTER(Architecture)(PlatformArchitecture_T *aArchitecture)
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%p\n", this, "Platform::getArchitecture", aArchitecture));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aArchitecture);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARCHITECTURE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getArchitecture(aArchitecture);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARCHITECTURE_RETURN(this, hrc, 0 /*normal*/,*aArchitecture);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARCHITECTURE_RETURN(this, hrc, 1 /*hrc exception*/,*aArchitecture);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/,*aArchitecture);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aArchitecture=%RU32 hrc=%Rhrc\n", this, "Platform::getArchitecture", !RT_VALID_PTR(aArchitecture) ? 0 : *aArchitecture, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMSETTER(Architecture)(PlatformArchitecture_T aArchitecture)
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%RU32\n", this, "Platform::setArchitecture", aArchitecture));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_ARCHITECTURE_ENTER(this, aArchitecture);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setArchitecture(aArchitecture);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_ARCHITECTURE_RETURN(this, hrc, 0 /*normal*/,aArchitecture);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_ARCHITECTURE_RETURN(this, hrc, 1 /*hrc exception*/,aArchitecture);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_ARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/,aArchitecture);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Platform::setArchitecture", hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(Properties)(IPlatformProperties **aProperties)
{
    LogRelFlow(("{%p} %s: enter aProperties=%p\n", this, "Platform::getProperties", aProperties));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProperties);
        ComTypeOutConverter<IPlatformProperties> TmpProperties(aProperties);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_PROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperties(TmpProperties.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_PROPERTIES_RETURN(this, hrc, 0 /*normal*/,(void *)TmpProperties.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_PROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_PROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProperties=%p hrc=%Rhrc\n", this, "Platform::getProperties", !RT_VALID_PTR(aProperties) ? 0 : *aProperties, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(X86)(IPlatformX86 **aX86)
{
    LogRelFlow(("{%p} %s: enter aX86=%p\n", this, "Platform::getX86", aX86));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aX86);
        ComTypeOutConverter<IPlatformX86> TmpX86(aX86);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_X86_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getX86(TmpX86.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_X86_RETURN(this, hrc, 0 /*normal*/,(void *)TmpX86.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_X86_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_X86_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aX86=%p hrc=%Rhrc\n", this, "Platform::getX86", !RT_VALID_PTR(aX86) ? 0 : *aX86, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(ARM)(IPlatformARM **aARM)
{
    LogRelFlow(("{%p} %s: enter aARM=%p\n", this, "Platform::getARM", aARM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aARM);
        ComTypeOutConverter<IPlatformARM> TmpARM(aARM);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getARM(TmpARM.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpARM.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_ARM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aARM=%p hrc=%Rhrc\n", this, "Platform::getARM", !RT_VALID_PTR(aARM) ? 0 : *aARM, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(ChipsetType)(ChipsetType_T *aChipsetType)
{
    LogRelFlow(("{%p} %s: enter aChipsetType=%p\n", this, "Platform::getChipsetType", aChipsetType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChipsetType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_CHIPSETTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChipsetType(aChipsetType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_CHIPSETTYPE_RETURN(this, hrc, 0 /*normal*/,*aChipsetType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_CHIPSETTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aChipsetType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_CHIPSETTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aChipsetType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChipsetType=%RU32 hrc=%Rhrc\n", this, "Platform::getChipsetType", !RT_VALID_PTR(aChipsetType) ? 0 : *aChipsetType, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMSETTER(ChipsetType)(ChipsetType_T aChipsetType)
{
    LogRelFlow(("{%p} %s: enter aChipsetType=%RU32\n", this, "Platform::setChipsetType", aChipsetType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_CHIPSETTYPE_ENTER(this, aChipsetType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setChipsetType(aChipsetType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_CHIPSETTYPE_RETURN(this, hrc, 0 /*normal*/,aChipsetType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_CHIPSETTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aChipsetType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_CHIPSETTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aChipsetType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Platform::setChipsetType", hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(IommuType)(IommuType_T *aIommuType)
{
    LogRelFlow(("{%p} %s: enter aIommuType=%p\n", this, "Platform::getIommuType", aIommuType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIommuType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_IOMMUTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIommuType(aIommuType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_IOMMUTYPE_RETURN(this, hrc, 0 /*normal*/,*aIommuType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_IOMMUTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aIommuType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_IOMMUTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIommuType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIommuType=%RU32 hrc=%Rhrc\n", this, "Platform::getIommuType", !RT_VALID_PTR(aIommuType) ? 0 : *aIommuType, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMSETTER(IommuType)(IommuType_T aIommuType)
{
    LogRelFlow(("{%p} %s: enter aIommuType=%RU32\n", this, "Platform::setIommuType", aIommuType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_IOMMUTYPE_ENTER(this, aIommuType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIommuType(aIommuType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_IOMMUTYPE_RETURN(this, hrc, 0 /*normal*/,aIommuType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_IOMMUTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aIommuType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_IOMMUTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aIommuType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Platform::setIommuType", hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(RTCUseUTC)(BOOL *aRTCUseUTC)
{
    LogRelFlow(("{%p} %s: enter aRTCUseUTC=%p\n", this, "Platform::getRTCUseUTC", aRTCUseUTC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRTCUseUTC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_RTCUSEUTC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRTCUseUTC(aRTCUseUTC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_RTCUSEUTC_RETURN(this, hrc, 0 /*normal*/,*aRTCUseUTC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_RTCUSEUTC_RETURN(this, hrc, 1 /*hrc exception*/,*aRTCUseUTC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_GET_RTCUSEUTC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRTCUseUTC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRTCUseUTC=%RTbool hrc=%Rhrc\n", this, "Platform::getRTCUseUTC", !RT_VALID_PTR(aRTCUseUTC) ? 0 : *aRTCUseUTC, hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMSETTER(RTCUseUTC)(BOOL aRTCUseUTC)
{
    LogRelFlow(("{%p} %s: enter aRTCUseUTC=%RTbool\n", this, "Platform::setRTCUseUTC", aRTCUseUTC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_RTCUSEUTC_ENTER(this, aRTCUseUTC != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRTCUseUTC(aRTCUseUTC != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_RTCUSEUTC_RETURN(this, hrc, 0 /*normal*/,aRTCUseUTC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_RTCUSEUTC_RETURN(this, hrc, 1 /*hrc exception*/,aRTCUseUTC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORM_SET_RTCUSEUTC_RETURN(this, hrc, 9 /*unhandled exception*/,aRTCUseUTC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Platform::setRTCUseUTC", hrc));
    return hrc;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute1IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute2IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute3IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute4IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute5IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute6IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute7IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute8IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute9IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute10IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute11IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute12IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute13IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute14IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute15IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::COMGETTER(InternalAndReservedAttribute16IPlatform)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPlatform methods
//

STDMETHODIMP PlatformWrap::InternalAndReservedMethod1IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod2IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod3IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod4IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod5IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod6IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod7IPlatform()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformWrap::InternalAndReservedMethod8IPlatform()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PlatformWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PlatformWrap, IPlatform)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PlatformWrap.cpp"


// ##### BEGINFILE "PlatformARMWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPlatformARM.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PLATFORMARM

#include "PlatformARMWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PlatformARMWrap)

//
// IPlatformARM properties
//

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute1IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute2IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute3IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute4IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute5IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute6IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute7IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute8IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute9IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute10IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute11IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute12IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute13IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute14IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute15IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::COMGETTER(InternalAndReservedAttribute16IPlatformARM)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPlatformARM methods
//

STDMETHODIMP PlatformARMWrap::GetCPUProperty(CPUPropertyTypeARM_T aProperty,
                                             BOOL *aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%p\n", this, "PlatformARM::getCPUProperty", aProperty, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_GETCPUPROPERTY_ENTER(this, aProperty);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUProperty(aProperty,
                                 aValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_GETCPUPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, *aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_GETCPUPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, aProperty, *aValue != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_GETCPUPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, *aValue != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%RTbool hrc=%Rhrc\n", this, "PlatformARM::getCPUProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP PlatformARMWrap::SetCPUProperty(CPUPropertyTypeARM_T aProperty,
                                             BOOL aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%RTbool\n", this, "PlatformARM::setCPUProperty", aProperty, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_SETCPUPROPERTY_ENTER(this, aProperty, aValue != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUProperty(aProperty,
                                 aValue != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_SETCPUPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_SETCPUPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, aProperty, aValue != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMARM_SETCPUPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, aValue != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "PlatformARM::setCPUProperty", hrc));
    return hrc;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod1IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod2IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod3IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod4IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod5IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod6IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod7IPlatformARM()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformARMWrap::InternalAndReservedMethod8IPlatformARM()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PlatformARMWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PlatformARMWrap, IPlatformARM)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PlatformARMWrap.cpp"


// ##### BEGINFILE "MachineWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMachine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MACHINE

#include "MachineWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MachineWrap)

//
// IMachine properties
//

STDMETHODIMP MachineWrap::COMGETTER(Parent)(IVirtualBox **aParent)
{
    LogRelFlow(("{%p} %s: enter aParent=%p\n", this, "Machine::getParent", aParent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParent);
        ComTypeOutConverter<IVirtualBox> TmpParent(aParent);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARENT_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParent(TmpParent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARENT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpParent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARENT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARENT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParent=%p hrc=%Rhrc\n", this, "Machine::getParent", !RT_VALID_PTR(aParent) ? 0 : *aParent, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Icon)(ComSafeArrayOut(BYTE, aIcon))
{
    LogRelFlow(("{%p} %s: enter aIcon=%p\n", this, "Machine::getIcon", aIcon));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIcon);
        ArrayOutConverter<BYTE> TmpIcon(ComSafeArrayOutArg(aIcon));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ICON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIcon(TmpIcon.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ICON_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpIcon.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ICON_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ICON_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIcon=%zu hrc=%Rhrc\n", this, "Machine::getIcon", !RT_VALID_PTR(aIcon) ? 0 : ComSafeArraySize(*aIcon), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(Icon)(ComSafeArrayIn(BYTE, aIcon))
{
    LogRelFlow(("{%p} %s: enter aIcon=%zu\n", this, "Machine::setIcon", ComSafeArraySize(aIcon)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayInConverter<BYTE> TmpIcon(ComSafeArrayInArg(aIcon));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ICON_ENTER(this, (uint32_t)TmpIcon.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIcon(TmpIcon.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ICON_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpIcon.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ICON_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ICON_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setIcon", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Accessible)(BOOL *aAccessible)
{
    LogRelFlow(("{%p} %s: enter aAccessible=%p\n", this, "Machine::getAccessible", aAccessible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSIBLE_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessible(aAccessible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 0 /*normal*/,*aAccessible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessible=%RTbool hrc=%Rhrc\n", this, "Machine::getAccessible", !RT_VALID_PTR(aAccessible) ? 0 : *aAccessible, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AccessError)(IVirtualBoxErrorInfo **aAccessError)
{
    LogRelFlow(("{%p} %s: enter aAccessError=%p\n", this, "Machine::getAccessError", aAccessError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessError);
        ComTypeOutConverter<IVirtualBoxErrorInfo> TmpAccessError(aAccessError);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSERROR_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessError(TmpAccessError.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSERROR_RETURN(this, hrc, 0 /*normal*/,(void *)TmpAccessError.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSERROR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ACCESSERROR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessError=%p hrc=%Rhrc\n", this, "Machine::getAccessError", !RT_VALID_PTR(aAccessError) ? 0 : *aAccessError, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Machine::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Machine::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Machine::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setName", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Machine::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Machine::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(Description)(IN_BSTR aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%ls\n", this, "Machine::setDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DESCRIPTION_ENTER(this, TmpDescription.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setDescription", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Machine::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ID_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Machine::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Groups)(ComSafeArrayOut(BSTR, aGroups))
{
    LogRelFlow(("{%p} %s: enter aGroups=%p\n", this, "Machine::getGroups", aGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroups);
        ArrayBSTROutConverter TmpGroups(ComSafeArrayOutArg(aGroups));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGroups(TmpGroups.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GROUPS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGroups.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GROUPS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGroups=%zu hrc=%Rhrc\n", this, "Machine::getGroups", !RT_VALID_PTR(aGroups) ? 0 : ComSafeArraySize(*aGroups), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(Groups)(ComSafeArrayIn(IN_BSTR, aGroups))
{
    LogRelFlow(("{%p} %s: enter aGroups=%zu\n", this, "Machine::setGroups", ComSafeArraySize(aGroups)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayBSTRInConverter TmpGroups(ComSafeArrayInArg(aGroups));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_GROUPS_ENTER(this, (uint32_t)TmpGroups.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setGroups(TmpGroups.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_GROUPS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGroups.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_GROUPS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_GROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setGroups", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
{
    LogRelFlow(("{%p} %s: enter aOSTypeId=%p\n", this, "Machine::getOSTypeId", aOSTypeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOSTypeId);
        BSTROutConverter TmpOSTypeId(aOSTypeId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_OSTYPEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOSTypeId(TmpOSTypeId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_OSTYPEID_RETURN(this, hrc, 0 /*normal*/,TmpOSTypeId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_OSTYPEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_OSTYPEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOSTypeId=%ls hrc=%Rhrc\n", this, "Machine::getOSTypeId", !RT_VALID_PTR(aOSTypeId) ? 0 : *aOSTypeId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(OSTypeId)(IN_BSTR aOSTypeId)
{
    LogRelFlow(("{%p} %s: enter aOSTypeId=%ls\n", this, "Machine::setOSTypeId", aOSTypeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpOSTypeId(aOSTypeId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_OSTYPEID_ENTER(this, TmpOSTypeId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setOSTypeId(TmpOSTypeId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_OSTYPEID_RETURN(this, hrc, 0 /*normal*/,TmpOSTypeId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_OSTYPEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_OSTYPEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setOSTypeId", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(HardwareVersion)(BSTR *aHardwareVersion)
{
    LogRelFlow(("{%p} %s: enter aHardwareVersion=%p\n", this, "Machine::getHardwareVersion", aHardwareVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardwareVersion);
        BSTROutConverter TmpHardwareVersion(aHardwareVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardwareVersion(TmpHardwareVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREVERSION_RETURN(this, hrc, 0 /*normal*/,TmpHardwareVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardwareVersion=%ls hrc=%Rhrc\n", this, "Machine::getHardwareVersion", !RT_VALID_PTR(aHardwareVersion) ? 0 : *aHardwareVersion, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(HardwareVersion)(IN_BSTR aHardwareVersion)
{
    LogRelFlow(("{%p} %s: enter aHardwareVersion=%ls\n", this, "Machine::setHardwareVersion", aHardwareVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpHardwareVersion(aHardwareVersion);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREVERSION_ENTER(this, TmpHardwareVersion.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHardwareVersion(TmpHardwareVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREVERSION_RETURN(this, hrc, 0 /*normal*/,TmpHardwareVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setHardwareVersion", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(HardwareUUID)(BSTR *aHardwareUUID)
{
    LogRelFlow(("{%p} %s: enter aHardwareUUID=%p\n", this, "Machine::getHardwareUUID", aHardwareUUID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardwareUUID);
        UuidOutConverter TmpHardwareUUID(aHardwareUUID);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREUUID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardwareUUID(TmpHardwareUUID.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREUUID_RETURN(this, hrc, 0 /*normal*/,TmpHardwareUUID.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREUUID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_HARDWAREUUID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardwareUUID=%ls hrc=%Rhrc\n", this, "Machine::getHardwareUUID", !RT_VALID_PTR(aHardwareUUID) ? 0 : *aHardwareUUID, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(HardwareUUID)(IN_BSTR aHardwareUUID)
{
    LogRelFlow(("{%p} %s: enter aHardwareUUID=%ls\n", this, "Machine::setHardwareUUID", aHardwareUUID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        UuidInConverter TmpHardwareUUID(aHardwareUUID);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREUUID_ENTER(this, TmpHardwareUUID.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHardwareUUID(TmpHardwareUUID.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREUUID_RETURN(this, hrc, 0 /*normal*/,TmpHardwareUUID.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREUUID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_HARDWAREUUID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setHardwareUUID", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CPUCount)(ULONG *aCPUCount)
{
    LogRelFlow(("{%p} %s: enter aCPUCount=%p\n", this, "Machine::getCPUCount", aCPUCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCPUCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUCount(aCPUCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUCOUNT_RETURN(this, hrc, 0 /*normal*/,*aCPUCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCPUCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCPUCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCPUCount=%RU32 hrc=%Rhrc\n", this, "Machine::getCPUCount", !RT_VALID_PTR(aCPUCount) ? 0 : *aCPUCount, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(CPUCount)(ULONG aCPUCount)
{
    LogRelFlow(("{%p} %s: enter aCPUCount=%RU32\n", this, "Machine::setCPUCount", aCPUCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUCOUNT_ENTER(this, aCPUCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUCount(aCPUCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUCOUNT_RETURN(this, hrc, 0 /*normal*/,aCPUCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aCPUCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aCPUCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setCPUCount", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CPUHotPlugEnabled)(BOOL *aCPUHotPlugEnabled)
{
    LogRelFlow(("{%p} %s: enter aCPUHotPlugEnabled=%p\n", this, "Machine::getCPUHotPlugEnabled", aCPUHotPlugEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCPUHotPlugEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUHOTPLUGENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUHotPlugEnabled(aCPUHotPlugEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUHOTPLUGENABLED_RETURN(this, hrc, 0 /*normal*/,*aCPUHotPlugEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUHOTPLUGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aCPUHotPlugEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUHOTPLUGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCPUHotPlugEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCPUHotPlugEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getCPUHotPlugEnabled", !RT_VALID_PTR(aCPUHotPlugEnabled) ? 0 : *aCPUHotPlugEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(CPUHotPlugEnabled)(BOOL aCPUHotPlugEnabled)
{
    LogRelFlow(("{%p} %s: enter aCPUHotPlugEnabled=%RTbool\n", this, "Machine::setCPUHotPlugEnabled", aCPUHotPlugEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUHOTPLUGENABLED_ENTER(this, aCPUHotPlugEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUHotPlugEnabled(aCPUHotPlugEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUHOTPLUGENABLED_RETURN(this, hrc, 0 /*normal*/,aCPUHotPlugEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUHOTPLUGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aCPUHotPlugEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUHOTPLUGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aCPUHotPlugEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setCPUHotPlugEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CPUExecutionCap)(ULONG *aCPUExecutionCap)
{
    LogRelFlow(("{%p} %s: enter aCPUExecutionCap=%p\n", this, "Machine::getCPUExecutionCap", aCPUExecutionCap));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCPUExecutionCap);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUEXECUTIONCAP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUExecutionCap(aCPUExecutionCap);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUEXECUTIONCAP_RETURN(this, hrc, 0 /*normal*/,*aCPUExecutionCap);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUEXECUTIONCAP_RETURN(this, hrc, 1 /*hrc exception*/,*aCPUExecutionCap);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUEXECUTIONCAP_RETURN(this, hrc, 9 /*unhandled exception*/,*aCPUExecutionCap);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCPUExecutionCap=%RU32 hrc=%Rhrc\n", this, "Machine::getCPUExecutionCap", !RT_VALID_PTR(aCPUExecutionCap) ? 0 : *aCPUExecutionCap, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(CPUExecutionCap)(ULONG aCPUExecutionCap)
{
    LogRelFlow(("{%p} %s: enter aCPUExecutionCap=%RU32\n", this, "Machine::setCPUExecutionCap", aCPUExecutionCap));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUEXECUTIONCAP_ENTER(this, aCPUExecutionCap);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUExecutionCap(aCPUExecutionCap);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUEXECUTIONCAP_RETURN(this, hrc, 0 /*normal*/,aCPUExecutionCap);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUEXECUTIONCAP_RETURN(this, hrc, 1 /*hrc exception*/,aCPUExecutionCap);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUEXECUTIONCAP_RETURN(this, hrc, 9 /*unhandled exception*/,aCPUExecutionCap);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setCPUExecutionCap", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CPUIDPortabilityLevel)(ULONG *aCPUIDPortabilityLevel)
{
    LogRelFlow(("{%p} %s: enter aCPUIDPortabilityLevel=%p\n", this, "Machine::getCPUIDPortabilityLevel", aCPUIDPortabilityLevel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCPUIDPortabilityLevel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUIDPORTABILITYLEVEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUIDPortabilityLevel(aCPUIDPortabilityLevel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 0 /*normal*/,*aCPUIDPortabilityLevel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 1 /*hrc exception*/,*aCPUIDPortabilityLevel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aCPUIDPortabilityLevel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCPUIDPortabilityLevel=%RU32 hrc=%Rhrc\n", this, "Machine::getCPUIDPortabilityLevel", !RT_VALID_PTR(aCPUIDPortabilityLevel) ? 0 : *aCPUIDPortabilityLevel, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(CPUIDPortabilityLevel)(ULONG aCPUIDPortabilityLevel)
{
    LogRelFlow(("{%p} %s: enter aCPUIDPortabilityLevel=%RU32\n", this, "Machine::setCPUIDPortabilityLevel", aCPUIDPortabilityLevel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUIDPORTABILITYLEVEL_ENTER(this, aCPUIDPortabilityLevel);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUIDPortabilityLevel(aCPUIDPortabilityLevel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 0 /*normal*/,aCPUIDPortabilityLevel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 1 /*hrc exception*/,aCPUIDPortabilityLevel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUIDPORTABILITYLEVEL_RETURN(this, hrc, 9 /*unhandled exception*/,aCPUIDPortabilityLevel);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setCPUIDPortabilityLevel", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(MemorySize)(ULONG *aMemorySize)
{
    LogRelFlow(("{%p} %s: enter aMemorySize=%p\n", this, "Machine::getMemorySize", aMemorySize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMemorySize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMemorySize(aMemorySize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYSIZE_RETURN(this, hrc, 0 /*normal*/,*aMemorySize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aMemorySize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMemorySize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMemorySize=%RU32 hrc=%Rhrc\n", this, "Machine::getMemorySize", !RT_VALID_PTR(aMemorySize) ? 0 : *aMemorySize, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(MemorySize)(ULONG aMemorySize)
{
    LogRelFlow(("{%p} %s: enter aMemorySize=%RU32\n", this, "Machine::setMemorySize", aMemorySize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYSIZE_ENTER(this, aMemorySize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMemorySize(aMemorySize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYSIZE_RETURN(this, hrc, 0 /*normal*/,aMemorySize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYSIZE_RETURN(this, hrc, 1 /*hrc exception*/,aMemorySize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aMemorySize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setMemorySize", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(MemoryBalloonSize)(ULONG *aMemoryBalloonSize)
{
    LogRelFlow(("{%p} %s: enter aMemoryBalloonSize=%p\n", this, "Machine::getMemoryBalloonSize", aMemoryBalloonSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMemoryBalloonSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYBALLOONSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMemoryBalloonSize(aMemoryBalloonSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYBALLOONSIZE_RETURN(this, hrc, 0 /*normal*/,*aMemoryBalloonSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYBALLOONSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aMemoryBalloonSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEMORYBALLOONSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMemoryBalloonSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMemoryBalloonSize=%RU32 hrc=%Rhrc\n", this, "Machine::getMemoryBalloonSize", !RT_VALID_PTR(aMemoryBalloonSize) ? 0 : *aMemoryBalloonSize, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(MemoryBalloonSize)(ULONG aMemoryBalloonSize)
{
    LogRelFlow(("{%p} %s: enter aMemoryBalloonSize=%RU32\n", this, "Machine::setMemoryBalloonSize", aMemoryBalloonSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYBALLOONSIZE_ENTER(this, aMemoryBalloonSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMemoryBalloonSize(aMemoryBalloonSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYBALLOONSIZE_RETURN(this, hrc, 0 /*normal*/,aMemoryBalloonSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYBALLOONSIZE_RETURN(this, hrc, 1 /*hrc exception*/,aMemoryBalloonSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_MEMORYBALLOONSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aMemoryBalloonSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setMemoryBalloonSize", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(PageFusionEnabled)(BOOL *aPageFusionEnabled)
{
    LogRelFlow(("{%p} %s: enter aPageFusionEnabled=%p\n", this, "Machine::getPageFusionEnabled", aPageFusionEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPageFusionEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PAGEFUSIONENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPageFusionEnabled(aPageFusionEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PAGEFUSIONENABLED_RETURN(this, hrc, 0 /*normal*/,*aPageFusionEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PAGEFUSIONENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aPageFusionEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PAGEFUSIONENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aPageFusionEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPageFusionEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getPageFusionEnabled", !RT_VALID_PTR(aPageFusionEnabled) ? 0 : *aPageFusionEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(PageFusionEnabled)(BOOL aPageFusionEnabled)
{
    LogRelFlow(("{%p} %s: enter aPageFusionEnabled=%RTbool\n", this, "Machine::setPageFusionEnabled", aPageFusionEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PAGEFUSIONENABLED_ENTER(this, aPageFusionEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPageFusionEnabled(aPageFusionEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PAGEFUSIONENABLED_RETURN(this, hrc, 0 /*normal*/,aPageFusionEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PAGEFUSIONENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aPageFusionEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PAGEFUSIONENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aPageFusionEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setPageFusionEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(GraphicsAdapter)(IGraphicsAdapter **aGraphicsAdapter)
{
    LogRelFlow(("{%p} %s: enter aGraphicsAdapter=%p\n", this, "Machine::getGraphicsAdapter", aGraphicsAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGraphicsAdapter);
        ComTypeOutConverter<IGraphicsAdapter> TmpGraphicsAdapter(aGraphicsAdapter);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GRAPHICSADAPTER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGraphicsAdapter(TmpGraphicsAdapter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GRAPHICSADAPTER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpGraphicsAdapter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GRAPHICSADAPTER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GRAPHICSADAPTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGraphicsAdapter=%p hrc=%Rhrc\n", this, "Machine::getGraphicsAdapter", !RT_VALID_PTR(aGraphicsAdapter) ? 0 : *aGraphicsAdapter, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(Platform)(IPlatform **aPlatform)
{
    LogRelFlow(("{%p} %s: enter aPlatform=%p\n", this, "Machine::getPlatform", aPlatform));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlatform);
        ComTypeOutConverter<IPlatform> TmpPlatform(aPlatform);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PLATFORM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlatform(TmpPlatform.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PLATFORM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpPlatform.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PLATFORM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PLATFORM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlatform=%p hrc=%Rhrc\n", this, "Machine::getPlatform", !RT_VALID_PTR(aPlatform) ? 0 : *aPlatform, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(FirmwareSettings)(IFirmwareSettings **aFirmwareSettings)
{
    LogRelFlow(("{%p} %s: enter aFirmwareSettings=%p\n", this, "Machine::getFirmwareSettings", aFirmwareSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFirmwareSettings);
        ComTypeOutConverter<IFirmwareSettings> TmpFirmwareSettings(aFirmwareSettings);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_FIRMWARESETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFirmwareSettings(TmpFirmwareSettings.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_FIRMWARESETTINGS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpFirmwareSettings.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_FIRMWARESETTINGS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_FIRMWARESETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFirmwareSettings=%p hrc=%Rhrc\n", this, "Machine::getFirmwareSettings", !RT_VALID_PTR(aFirmwareSettings) ? 0 : *aFirmwareSettings, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TrustedPlatformModule)(ITrustedPlatformModule **aTrustedPlatformModule)
{
    LogRelFlow(("{%p} %s: enter aTrustedPlatformModule=%p\n", this, "Machine::getTrustedPlatformModule", aTrustedPlatformModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTrustedPlatformModule);
        ComTypeOutConverter<ITrustedPlatformModule> TmpTrustedPlatformModule(aTrustedPlatformModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRUSTEDPLATFORMMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTrustedPlatformModule(TmpTrustedPlatformModule.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRUSTEDPLATFORMMODULE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpTrustedPlatformModule.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRUSTEDPLATFORMMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRUSTEDPLATFORMMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTrustedPlatformModule=%p hrc=%Rhrc\n", this, "Machine::getTrustedPlatformModule", !RT_VALID_PTR(aTrustedPlatformModule) ? 0 : *aTrustedPlatformModule, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(NonVolatileStore)(INvramStore **aNonVolatileStore)
{
    LogRelFlow(("{%p} %s: enter aNonVolatileStore=%p\n", this, "Machine::getNonVolatileStore", aNonVolatileStore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNonVolatileStore);
        ComTypeOutConverter<INvramStore> TmpNonVolatileStore(aNonVolatileStore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NONVOLATILESTORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNonVolatileStore(TmpNonVolatileStore.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NONVOLATILESTORE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpNonVolatileStore.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NONVOLATILESTORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_NONVOLATILESTORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNonVolatileStore=%p hrc=%Rhrc\n", this, "Machine::getNonVolatileStore", !RT_VALID_PTR(aNonVolatileStore) ? 0 : *aNonVolatileStore, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(RecordingSettings)(IRecordingSettings **aRecordingSettings)
{
    LogRelFlow(("{%p} %s: enter aRecordingSettings=%p\n", this, "Machine::getRecordingSettings", aRecordingSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecordingSettings);
        ComTypeOutConverter<IRecordingSettings> TmpRecordingSettings(aRecordingSettings);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_RECORDINGSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecordingSettings(TmpRecordingSettings.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_RECORDINGSETTINGS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpRecordingSettings.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_RECORDINGSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_RECORDINGSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecordingSettings=%p hrc=%Rhrc\n", this, "Machine::getRecordingSettings", !RT_VALID_PTR(aRecordingSettings) ? 0 : *aRecordingSettings, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(PointingHIDType)(PointingHIDType_T *aPointingHIDType)
{
    LogRelFlow(("{%p} %s: enter aPointingHIDType=%p\n", this, "Machine::getPointingHIDType", aPointingHIDType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPointingHIDType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_POINTINGHIDTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPointingHIDType(aPointingHIDType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_POINTINGHIDTYPE_RETURN(this, hrc, 0 /*normal*/,*aPointingHIDType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_POINTINGHIDTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aPointingHIDType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_POINTINGHIDTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aPointingHIDType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPointingHIDType=%RU32 hrc=%Rhrc\n", this, "Machine::getPointingHIDType", !RT_VALID_PTR(aPointingHIDType) ? 0 : *aPointingHIDType, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(PointingHIDType)(PointingHIDType_T aPointingHIDType)
{
    LogRelFlow(("{%p} %s: enter aPointingHIDType=%RU32\n", this, "Machine::setPointingHIDType", aPointingHIDType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_POINTINGHIDTYPE_ENTER(this, aPointingHIDType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPointingHIDType(aPointingHIDType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_POINTINGHIDTYPE_RETURN(this, hrc, 0 /*normal*/,aPointingHIDType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_POINTINGHIDTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aPointingHIDType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_POINTINGHIDTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aPointingHIDType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setPointingHIDType", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(KeyboardHIDType)(KeyboardHIDType_T *aKeyboardHIDType)
{
    LogRelFlow(("{%p} %s: enter aKeyboardHIDType=%p\n", this, "Machine::getKeyboardHIDType", aKeyboardHIDType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyboardHIDType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_KEYBOARDHIDTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyboardHIDType(aKeyboardHIDType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_KEYBOARDHIDTYPE_RETURN(this, hrc, 0 /*normal*/,*aKeyboardHIDType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_KEYBOARDHIDTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aKeyboardHIDType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_KEYBOARDHIDTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aKeyboardHIDType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyboardHIDType=%RU32 hrc=%Rhrc\n", this, "Machine::getKeyboardHIDType", !RT_VALID_PTR(aKeyboardHIDType) ? 0 : *aKeyboardHIDType, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(KeyboardHIDType)(KeyboardHIDType_T aKeyboardHIDType)
{
    LogRelFlow(("{%p} %s: enter aKeyboardHIDType=%RU32\n", this, "Machine::setKeyboardHIDType", aKeyboardHIDType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_KEYBOARDHIDTYPE_ENTER(this, aKeyboardHIDType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setKeyboardHIDType(aKeyboardHIDType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_KEYBOARDHIDTYPE_RETURN(this, hrc, 0 /*normal*/,aKeyboardHIDType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_KEYBOARDHIDTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aKeyboardHIDType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_KEYBOARDHIDTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aKeyboardHIDType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setKeyboardHIDType", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SnapshotFolder)(BSTR *aSnapshotFolder)
{
    LogRelFlow(("{%p} %s: enter aSnapshotFolder=%p\n", this, "Machine::getSnapshotFolder", aSnapshotFolder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSnapshotFolder);
        BSTROutConverter TmpSnapshotFolder(aSnapshotFolder);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTFOLDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSnapshotFolder(TmpSnapshotFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpSnapshotFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSnapshotFolder=%ls hrc=%Rhrc\n", this, "Machine::getSnapshotFolder", !RT_VALID_PTR(aSnapshotFolder) ? 0 : *aSnapshotFolder, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(SnapshotFolder)(IN_BSTR aSnapshotFolder)
{
    LogRelFlow(("{%p} %s: enter aSnapshotFolder=%ls\n", this, "Machine::setSnapshotFolder", aSnapshotFolder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpSnapshotFolder(aSnapshotFolder);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_SNAPSHOTFOLDER_ENTER(this, TmpSnapshotFolder.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSnapshotFolder(TmpSnapshotFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_SNAPSHOTFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpSnapshotFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_SNAPSHOTFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_SNAPSHOTFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setSnapshotFolder", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(VRDEServer)(IVRDEServer **aVRDEServer)
{
    LogRelFlow(("{%p} %s: enter aVRDEServer=%p\n", this, "Machine::getVRDEServer", aVRDEServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEServer);
        ComTypeOutConverter<IVRDEServer> TmpVRDEServer(aVRDEServer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VRDESERVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEServer(TmpVRDEServer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VRDESERVER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpVRDEServer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VRDESERVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VRDESERVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEServer=%p hrc=%Rhrc\n", this, "Machine::getVRDEServer", !RT_VALID_PTR(aVRDEServer) ? 0 : *aVRDEServer, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(EmulatedUSBCardReaderEnabled)(BOOL *aEmulatedUSBCardReaderEnabled)
{
    LogRelFlow(("{%p} %s: enter aEmulatedUSBCardReaderEnabled=%p\n", this, "Machine::getEmulatedUSBCardReaderEnabled", aEmulatedUSBCardReaderEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEmulatedUSBCardReaderEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_EMULATEDUSBCARDREADERENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEmulatedUSBCardReaderEnabled(aEmulatedUSBCardReaderEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 0 /*normal*/,*aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEmulatedUSBCardReaderEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getEmulatedUSBCardReaderEnabled", !RT_VALID_PTR(aEmulatedUSBCardReaderEnabled) ? 0 : *aEmulatedUSBCardReaderEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(EmulatedUSBCardReaderEnabled)(BOOL aEmulatedUSBCardReaderEnabled)
{
    LogRelFlow(("{%p} %s: enter aEmulatedUSBCardReaderEnabled=%RTbool\n", this, "Machine::setEmulatedUSBCardReaderEnabled", aEmulatedUSBCardReaderEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_EMULATEDUSBCARDREADERENABLED_ENTER(this, aEmulatedUSBCardReaderEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEmulatedUSBCardReaderEnabled(aEmulatedUSBCardReaderEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 0 /*normal*/,aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_EMULATEDUSBCARDREADERENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEmulatedUSBCardReaderEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setEmulatedUSBCardReaderEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(MediumAttachments)(ComSafeArrayOut(IMediumAttachment *, aMediumAttachments))
{
    LogRelFlow(("{%p} %s: enter aMediumAttachments=%p\n", this, "Machine::getMediumAttachments", aMediumAttachments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMediumAttachments);
        ArrayComTypeOutConverter<IMediumAttachment> TmpMediumAttachments(ComSafeArrayOutArg(aMediumAttachments));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEDIUMATTACHMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumAttachments(TmpMediumAttachments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEDIUMATTACHMENTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMediumAttachments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEDIUMATTACHMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_MEDIUMATTACHMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMediumAttachments=%zu hrc=%Rhrc\n", this, "Machine::getMediumAttachments", !RT_VALID_PTR(aMediumAttachments) ? 0 : ComSafeArraySize(*aMediumAttachments), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(USBControllers)(ComSafeArrayOut(IUSBController *, aUSBControllers))
{
    LogRelFlow(("{%p} %s: enter aUSBControllers=%p\n", this, "Machine::getUSBControllers", aUSBControllers));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBControllers);
        ArrayComTypeOutConverter<IUSBController> TmpUSBControllers(ComSafeArrayOutArg(aUSBControllers));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBCONTROLLERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBControllers(TmpUSBControllers.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBCONTROLLERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpUSBControllers.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBCONTROLLERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBCONTROLLERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUSBControllers=%zu hrc=%Rhrc\n", this, "Machine::getUSBControllers", !RT_VALID_PTR(aUSBControllers) ? 0 : ComSafeArraySize(*aUSBControllers), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(USBDeviceFilters)(IUSBDeviceFilters **aUSBDeviceFilters)
{
    LogRelFlow(("{%p} %s: enter aUSBDeviceFilters=%p\n", this, "Machine::getUSBDeviceFilters", aUSBDeviceFilters));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBDeviceFilters);
        ComTypeOutConverter<IUSBDeviceFilters> TmpUSBDeviceFilters(aUSBDeviceFilters);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBDEVICEFILTERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBDeviceFilters(TmpUSBDeviceFilters.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBDEVICEFILTERS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpUSBDeviceFilters.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBDEVICEFILTERS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBDEVICEFILTERS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUSBDeviceFilters=%p hrc=%Rhrc\n", this, "Machine::getUSBDeviceFilters", !RT_VALID_PTR(aUSBDeviceFilters) ? 0 : *aUSBDeviceFilters, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AudioSettings)(IAudioSettings **aAudioSettings)
{
    LogRelFlow(("{%p} %s: enter aAudioSettings=%p\n", this, "Machine::getAudioSettings", aAudioSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAudioSettings);
        ComTypeOutConverter<IAudioSettings> TmpAudioSettings(aAudioSettings);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUDIOSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAudioSettings(TmpAudioSettings.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUDIOSETTINGS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpAudioSettings.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUDIOSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUDIOSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAudioSettings=%p hrc=%Rhrc\n", this, "Machine::getAudioSettings", !RT_VALID_PTR(aAudioSettings) ? 0 : *aAudioSettings, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(StorageControllers)(ComSafeArrayOut(IStorageController *, aStorageControllers))
{
    LogRelFlow(("{%p} %s: enter aStorageControllers=%p\n", this, "Machine::getStorageControllers", aStorageControllers));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStorageControllers);
        ArrayComTypeOutConverter<IStorageController> TmpStorageControllers(ComSafeArrayOutArg(aStorageControllers));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STORAGECONTROLLERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStorageControllers(TmpStorageControllers.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STORAGECONTROLLERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpStorageControllers.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STORAGECONTROLLERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STORAGECONTROLLERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStorageControllers=%zu hrc=%Rhrc\n", this, "Machine::getStorageControllers", !RT_VALID_PTR(aStorageControllers) ? 0 : ComSafeArraySize(*aStorageControllers), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SettingsFilePath)(BSTR *aSettingsFilePath)
{
    LogRelFlow(("{%p} %s: enter aSettingsFilePath=%p\n", this, "Machine::getSettingsFilePath", aSettingsFilePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSettingsFilePath);
        BSTROutConverter TmpSettingsFilePath(aSettingsFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSFILEPATH_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSettingsFilePath(TmpSettingsFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSFILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpSettingsFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSFILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSFILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSettingsFilePath=%ls hrc=%Rhrc\n", this, "Machine::getSettingsFilePath", !RT_VALID_PTR(aSettingsFilePath) ? 0 : *aSettingsFilePath, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SettingsAuxFilePath)(BSTR *aSettingsAuxFilePath)
{
    LogRelFlow(("{%p} %s: enter aSettingsAuxFilePath=%p\n", this, "Machine::getSettingsAuxFilePath", aSettingsAuxFilePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSettingsAuxFilePath);
        BSTROutConverter TmpSettingsAuxFilePath(aSettingsAuxFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSAUXFILEPATH_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSettingsAuxFilePath(TmpSettingsAuxFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSAUXFILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpSettingsAuxFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSAUXFILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSAUXFILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSettingsAuxFilePath=%ls hrc=%Rhrc\n", this, "Machine::getSettingsAuxFilePath", !RT_VALID_PTR(aSettingsAuxFilePath) ? 0 : *aSettingsAuxFilePath, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SettingsModified)(BOOL *aSettingsModified)
{
    LogRelFlow(("{%p} %s: enter aSettingsModified=%p\n", this, "Machine::getSettingsModified", aSettingsModified));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSettingsModified);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSMODIFIED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSettingsModified(aSettingsModified);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSMODIFIED_RETURN(this, hrc, 0 /*normal*/,*aSettingsModified != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSMODIFIED_RETURN(this, hrc, 1 /*hrc exception*/,*aSettingsModified != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SETTINGSMODIFIED_RETURN(this, hrc, 9 /*unhandled exception*/,*aSettingsModified != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSettingsModified=%RTbool hrc=%Rhrc\n", this, "Machine::getSettingsModified", !RT_VALID_PTR(aSettingsModified) ? 0 : *aSettingsModified, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SessionState)(SessionState_T *aSessionState)
{
    LogRelFlow(("{%p} %s: enter aSessionState=%p\n", this, "Machine::getSessionState", aSessionState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSessionState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONSTATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSessionState(aSessionState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONSTATE_RETURN(this, hrc, 0 /*normal*/,*aSessionState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONSTATE_RETURN(this, hrc, 1 /*hrc exception*/,*aSessionState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONSTATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSessionState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSessionState=%RU32 hrc=%Rhrc\n", this, "Machine::getSessionState", !RT_VALID_PTR(aSessionState) ? 0 : *aSessionState, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SessionName)(BSTR *aSessionName)
{
    LogRelFlow(("{%p} %s: enter aSessionName=%p\n", this, "Machine::getSessionName", aSessionName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSessionName);
        BSTROutConverter TmpSessionName(aSessionName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSessionName(TmpSessionName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONNAME_RETURN(this, hrc, 0 /*normal*/,TmpSessionName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSessionName=%ls hrc=%Rhrc\n", this, "Machine::getSessionName", !RT_VALID_PTR(aSessionName) ? 0 : *aSessionName, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SessionPID)(ULONG *aSessionPID)
{
    LogRelFlow(("{%p} %s: enter aSessionPID=%p\n", this, "Machine::getSessionPID", aSessionPID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSessionPID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONPID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSessionPID(aSessionPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONPID_RETURN(this, hrc, 0 /*normal*/,*aSessionPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONPID_RETURN(this, hrc, 1 /*hrc exception*/,*aSessionPID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SESSIONPID_RETURN(this, hrc, 9 /*unhandled exception*/,*aSessionPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSessionPID=%RU32 hrc=%Rhrc\n", this, "Machine::getSessionPID", !RT_VALID_PTR(aSessionPID) ? 0 : *aSessionPID, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(State)(MachineState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Machine::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "Machine::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(LastStateChange)(LONG64 *aLastStateChange)
{
    LogRelFlow(("{%p} %s: enter aLastStateChange=%p\n", this, "Machine::getLastStateChange", aLastStateChange));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastStateChange);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LASTSTATECHANGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastStateChange(aLastStateChange);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LASTSTATECHANGE_RETURN(this, hrc, 0 /*normal*/,*aLastStateChange);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LASTSTATECHANGE_RETURN(this, hrc, 1 /*hrc exception*/,*aLastStateChange);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LASTSTATECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/,*aLastStateChange);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastStateChange=%RI64 hrc=%Rhrc\n", this, "Machine::getLastStateChange", !RT_VALID_PTR(aLastStateChange) ? 0 : *aLastStateChange, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(StateFilePath)(BSTR *aStateFilePath)
{
    LogRelFlow(("{%p} %s: enter aStateFilePath=%p\n", this, "Machine::getStateFilePath", aStateFilePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStateFilePath);
        BSTROutConverter TmpStateFilePath(aStateFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEFILEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStateFilePath(TmpStateFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEFILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpStateFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEFILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEFILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStateFilePath=%ls hrc=%Rhrc\n", this, "Machine::getStateFilePath", !RT_VALID_PTR(aStateFilePath) ? 0 : *aStateFilePath, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(LogFolder)(BSTR *aLogFolder)
{
    LogRelFlow(("{%p} %s: enter aLogFolder=%p\n", this, "Machine::getLogFolder", aLogFolder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogFolder);
        BSTROutConverter TmpLogFolder(aLogFolder);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGFOLDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogFolder(TmpLogFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpLogFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogFolder=%ls hrc=%Rhrc\n", this, "Machine::getLogFolder", !RT_VALID_PTR(aLogFolder) ? 0 : *aLogFolder, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CurrentSnapshot)(ISnapshot **aCurrentSnapshot)
{
    LogRelFlow(("{%p} %s: enter aCurrentSnapshot=%p\n", this, "Machine::getCurrentSnapshot", aCurrentSnapshot));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCurrentSnapshot);
        ComTypeOutConverter<ISnapshot> TmpCurrentSnapshot(aCurrentSnapshot);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSNAPSHOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCurrentSnapshot(TmpCurrentSnapshot.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSNAPSHOT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpCurrentSnapshot.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSNAPSHOT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSNAPSHOT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCurrentSnapshot=%p hrc=%Rhrc\n", this, "Machine::getCurrentSnapshot", !RT_VALID_PTR(aCurrentSnapshot) ? 0 : *aCurrentSnapshot, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SnapshotCount)(ULONG *aSnapshotCount)
{
    LogRelFlow(("{%p} %s: enter aSnapshotCount=%p\n", this, "Machine::getSnapshotCount", aSnapshotCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSnapshotCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSnapshotCount(aSnapshotCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aSnapshotCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aSnapshotCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SNAPSHOTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSnapshotCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSnapshotCount=%RU32 hrc=%Rhrc\n", this, "Machine::getSnapshotCount", !RT_VALID_PTR(aSnapshotCount) ? 0 : *aSnapshotCount, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CurrentStateModified)(BOOL *aCurrentStateModified)
{
    LogRelFlow(("{%p} %s: enter aCurrentStateModified=%p\n", this, "Machine::getCurrentStateModified", aCurrentStateModified));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCurrentStateModified);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSTATEMODIFIED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCurrentStateModified(aCurrentStateModified);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSTATEMODIFIED_RETURN(this, hrc, 0 /*normal*/,*aCurrentStateModified != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSTATEMODIFIED_RETURN(this, hrc, 1 /*hrc exception*/,*aCurrentStateModified != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CURRENTSTATEMODIFIED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCurrentStateModified != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCurrentStateModified=%RTbool hrc=%Rhrc\n", this, "Machine::getCurrentStateModified", !RT_VALID_PTR(aCurrentStateModified) ? 0 : *aCurrentStateModified, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
{
    LogRelFlow(("{%p} %s: enter aSharedFolders=%p\n", this, "Machine::getSharedFolders", aSharedFolders));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSharedFolders);
        ArrayComTypeOutConverter<ISharedFolder> TmpSharedFolders(ComSafeArrayOutArg(aSharedFolders));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SHAREDFOLDERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSharedFolders(TmpSharedFolders.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SHAREDFOLDERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSharedFolders.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SHAREDFOLDERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_SHAREDFOLDERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSharedFolders=%zu hrc=%Rhrc\n", this, "Machine::getSharedFolders", !RT_VALID_PTR(aSharedFolders) ? 0 : ComSafeArraySize(*aSharedFolders), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(ClipboardMode)(ClipboardMode_T *aClipboardMode)
{
    LogRelFlow(("{%p} %s: enter aClipboardMode=%p\n", this, "Machine::getClipboardMode", aClipboardMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClipboardMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClipboardMode(aClipboardMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDMODE_RETURN(this, hrc, 0 /*normal*/,*aClipboardMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aClipboardMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aClipboardMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClipboardMode=%RU32 hrc=%Rhrc\n", this, "Machine::getClipboardMode", !RT_VALID_PTR(aClipboardMode) ? 0 : *aClipboardMode, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(ClipboardMode)(ClipboardMode_T aClipboardMode)
{
    LogRelFlow(("{%p} %s: enter aClipboardMode=%RU32\n", this, "Machine::setClipboardMode", aClipboardMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDMODE_ENTER(this, aClipboardMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setClipboardMode(aClipboardMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDMODE_RETURN(this, hrc, 0 /*normal*/,aClipboardMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDMODE_RETURN(this, hrc, 1 /*hrc exception*/,aClipboardMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aClipboardMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setClipboardMode", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(ClipboardFileTransfersEnabled)(BOOL *aClipboardFileTransfersEnabled)
{
    LogRelFlow(("{%p} %s: enter aClipboardFileTransfersEnabled=%p\n", this, "Machine::getClipboardFileTransfersEnabled", aClipboardFileTransfersEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClipboardFileTransfersEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDFILETRANSFERSENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClipboardFileTransfersEnabled(aClipboardFileTransfersEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 0 /*normal*/,*aClipboardFileTransfersEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aClipboardFileTransfersEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aClipboardFileTransfersEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClipboardFileTransfersEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getClipboardFileTransfersEnabled", !RT_VALID_PTR(aClipboardFileTransfersEnabled) ? 0 : *aClipboardFileTransfersEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(ClipboardFileTransfersEnabled)(BOOL aClipboardFileTransfersEnabled)
{
    LogRelFlow(("{%p} %s: enter aClipboardFileTransfersEnabled=%RTbool\n", this, "Machine::setClipboardFileTransfersEnabled", aClipboardFileTransfersEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDFILETRANSFERSENABLED_ENTER(this, aClipboardFileTransfersEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setClipboardFileTransfersEnabled(aClipboardFileTransfersEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 0 /*normal*/,aClipboardFileTransfersEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aClipboardFileTransfersEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CLIPBOARDFILETRANSFERSENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aClipboardFileTransfersEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setClipboardFileTransfersEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(DnDMode)(DnDMode_T *aDnDMode)
{
    LogRelFlow(("{%p} %s: enter aDnDMode=%p\n", this, "Machine::getDnDMode", aDnDMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDnDMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DNDMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDnDMode(aDnDMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DNDMODE_RETURN(this, hrc, 0 /*normal*/,*aDnDMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DNDMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aDnDMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DNDMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aDnDMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDnDMode=%RU32 hrc=%Rhrc\n", this, "Machine::getDnDMode", !RT_VALID_PTR(aDnDMode) ? 0 : *aDnDMode, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(DnDMode)(DnDMode_T aDnDMode)
{
    LogRelFlow(("{%p} %s: enter aDnDMode=%RU32\n", this, "Machine::setDnDMode", aDnDMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DNDMODE_ENTER(this, aDnDMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDnDMode(aDnDMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DNDMODE_RETURN(this, hrc, 0 /*normal*/,aDnDMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DNDMODE_RETURN(this, hrc, 1 /*hrc exception*/,aDnDMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DNDMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aDnDMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setDnDMode", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TeleporterEnabled)(BOOL *aTeleporterEnabled)
{
    LogRelFlow(("{%p} %s: enter aTeleporterEnabled=%p\n", this, "Machine::getTeleporterEnabled", aTeleporterEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTeleporterEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTeleporterEnabled(aTeleporterEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERENABLED_RETURN(this, hrc, 0 /*normal*/,*aTeleporterEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aTeleporterEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTeleporterEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTeleporterEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getTeleporterEnabled", !RT_VALID_PTR(aTeleporterEnabled) ? 0 : *aTeleporterEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TeleporterEnabled)(BOOL aTeleporterEnabled)
{
    LogRelFlow(("{%p} %s: enter aTeleporterEnabled=%RTbool\n", this, "Machine::setTeleporterEnabled", aTeleporterEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERENABLED_ENTER(this, aTeleporterEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTeleporterEnabled(aTeleporterEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERENABLED_RETURN(this, hrc, 0 /*normal*/,aTeleporterEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aTeleporterEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aTeleporterEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTeleporterEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TeleporterPort)(ULONG *aTeleporterPort)
{
    LogRelFlow(("{%p} %s: enter aTeleporterPort=%p\n", this, "Machine::getTeleporterPort", aTeleporterPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTeleporterPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTeleporterPort(aTeleporterPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPORT_RETURN(this, hrc, 0 /*normal*/,*aTeleporterPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPORT_RETURN(this, hrc, 1 /*hrc exception*/,*aTeleporterPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTeleporterPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTeleporterPort=%RU32 hrc=%Rhrc\n", this, "Machine::getTeleporterPort", !RT_VALID_PTR(aTeleporterPort) ? 0 : *aTeleporterPort, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TeleporterPort)(ULONG aTeleporterPort)
{
    LogRelFlow(("{%p} %s: enter aTeleporterPort=%RU32\n", this, "Machine::setTeleporterPort", aTeleporterPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPORT_ENTER(this, aTeleporterPort);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTeleporterPort(aTeleporterPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPORT_RETURN(this, hrc, 0 /*normal*/,aTeleporterPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPORT_RETURN(this, hrc, 1 /*hrc exception*/,aTeleporterPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPORT_RETURN(this, hrc, 9 /*unhandled exception*/,aTeleporterPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTeleporterPort", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TeleporterAddress)(BSTR *aTeleporterAddress)
{
    LogRelFlow(("{%p} %s: enter aTeleporterAddress=%p\n", this, "Machine::getTeleporterAddress", aTeleporterAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTeleporterAddress);
        BSTROutConverter TmpTeleporterAddress(aTeleporterAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTeleporterAddress(TmpTeleporterAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpTeleporterAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTeleporterAddress=%ls hrc=%Rhrc\n", this, "Machine::getTeleporterAddress", !RT_VALID_PTR(aTeleporterAddress) ? 0 : *aTeleporterAddress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TeleporterAddress)(IN_BSTR aTeleporterAddress)
{
    LogRelFlow(("{%p} %s: enter aTeleporterAddress=%ls\n", this, "Machine::setTeleporterAddress", aTeleporterAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTeleporterAddress(aTeleporterAddress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERADDRESS_ENTER(this, TmpTeleporterAddress.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTeleporterAddress(TmpTeleporterAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpTeleporterAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTeleporterAddress", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TeleporterPassword)(BSTR *aTeleporterPassword)
{
    LogRelFlow(("{%p} %s: enter aTeleporterPassword=%p\n", this, "Machine::getTeleporterPassword", aTeleporterPassword));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTeleporterPassword);
        BSTROutConverter TmpTeleporterPassword(aTeleporterPassword);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPASSWORD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTeleporterPassword(TmpTeleporterPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPASSWORD_RETURN(this, hrc, 0 /*normal*/,TmpTeleporterPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TELEPORTERPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTeleporterPassword=%ls hrc=%Rhrc\n", this, "Machine::getTeleporterPassword", !RT_VALID_PTR(aTeleporterPassword) ? 0 : *aTeleporterPassword, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TeleporterPassword)(IN_BSTR aTeleporterPassword)
{
    LogRelFlow(("{%p} %s: enter aTeleporterPassword=%ls\n", this, "Machine::setTeleporterPassword", aTeleporterPassword));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTeleporterPassword(aTeleporterPassword);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPASSWORD_ENTER(this, TmpTeleporterPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTeleporterPassword(TmpTeleporterPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPASSWORD_RETURN(this, hrc, 0 /*normal*/,TmpTeleporterPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TELEPORTERPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTeleporterPassword", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(ParavirtProvider)(ParavirtProvider_T *aParavirtProvider)
{
    LogRelFlow(("{%p} %s: enter aParavirtProvider=%p\n", this, "Machine::getParavirtProvider", aParavirtProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParavirtProvider);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTPROVIDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParavirtProvider(aParavirtProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTPROVIDER_RETURN(this, hrc, 0 /*normal*/,*aParavirtProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,*aParavirtProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aParavirtProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParavirtProvider=%RU32 hrc=%Rhrc\n", this, "Machine::getParavirtProvider", !RT_VALID_PTR(aParavirtProvider) ? 0 : *aParavirtProvider, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(ParavirtProvider)(ParavirtProvider_T aParavirtProvider)
{
    LogRelFlow(("{%p} %s: enter aParavirtProvider=%RU32\n", this, "Machine::setParavirtProvider", aParavirtProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTPROVIDER_ENTER(this, aParavirtProvider);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setParavirtProvider(aParavirtProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTPROVIDER_RETURN(this, hrc, 0 /*normal*/,aParavirtProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,aParavirtProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,aParavirtProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setParavirtProvider", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(IOCacheEnabled)(BOOL *aIOCacheEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOCacheEnabled=%p\n", this, "Machine::getIOCacheEnabled", aIOCacheEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIOCacheEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHEENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOCacheEnabled(aIOCacheEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHEENABLED_RETURN(this, hrc, 0 /*normal*/,*aIOCacheEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHEENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aIOCacheEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHEENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOCacheEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOCacheEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getIOCacheEnabled", !RT_VALID_PTR(aIOCacheEnabled) ? 0 : *aIOCacheEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(IOCacheEnabled)(BOOL aIOCacheEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOCacheEnabled=%RTbool\n", this, "Machine::setIOCacheEnabled", aIOCacheEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHEENABLED_ENTER(this, aIOCacheEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOCacheEnabled(aIOCacheEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHEENABLED_RETURN(this, hrc, 0 /*normal*/,aIOCacheEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHEENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aIOCacheEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHEENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aIOCacheEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setIOCacheEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(IOCacheSize)(ULONG *aIOCacheSize)
{
    LogRelFlow(("{%p} %s: enter aIOCacheSize=%p\n", this, "Machine::getIOCacheSize", aIOCacheSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIOCacheSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHESIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOCacheSize(aIOCacheSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHESIZE_RETURN(this, hrc, 0 /*normal*/,*aIOCacheSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHESIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aIOCacheSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_IOCACHESIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOCacheSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOCacheSize=%RU32 hrc=%Rhrc\n", this, "Machine::getIOCacheSize", !RT_VALID_PTR(aIOCacheSize) ? 0 : *aIOCacheSize, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(IOCacheSize)(ULONG aIOCacheSize)
{
    LogRelFlow(("{%p} %s: enter aIOCacheSize=%RU32\n", this, "Machine::setIOCacheSize", aIOCacheSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHESIZE_ENTER(this, aIOCacheSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOCacheSize(aIOCacheSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHESIZE_RETURN(this, hrc, 0 /*normal*/,aIOCacheSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHESIZE_RETURN(this, hrc, 1 /*hrc exception*/,aIOCacheSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_IOCACHESIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aIOCacheSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setIOCacheSize", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(PCIDeviceAssignments)(ComSafeArrayOut(IPCIDeviceAttachment *, aPCIDeviceAssignments))
{
    LogRelFlow(("{%p} %s: enter aPCIDeviceAssignments=%p\n", this, "Machine::getPCIDeviceAssignments", aPCIDeviceAssignments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPCIDeviceAssignments);
        ArrayComTypeOutConverter<IPCIDeviceAttachment> TmpPCIDeviceAssignments(ComSafeArrayOutArg(aPCIDeviceAssignments));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PCIDEVICEASSIGNMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPCIDeviceAssignments(TmpPCIDeviceAssignments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PCIDEVICEASSIGNMENTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPCIDeviceAssignments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PCIDEVICEASSIGNMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PCIDEVICEASSIGNMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPCIDeviceAssignments=%zu hrc=%Rhrc\n", this, "Machine::getPCIDeviceAssignments", !RT_VALID_PTR(aPCIDeviceAssignments) ? 0 : ComSafeArraySize(*aPCIDeviceAssignments), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(BandwidthControl)(IBandwidthControl **aBandwidthControl)
{
    LogRelFlow(("{%p} %s: enter aBandwidthControl=%p\n", this, "Machine::getBandwidthControl", aBandwidthControl));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthControl);
        ComTypeOutConverter<IBandwidthControl> TmpBandwidthControl(aBandwidthControl);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_BANDWIDTHCONTROL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBandwidthControl(TmpBandwidthControl.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_BANDWIDTHCONTROL_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBandwidthControl.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_BANDWIDTHCONTROL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_BANDWIDTHCONTROL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBandwidthControl=%p hrc=%Rhrc\n", this, "Machine::getBandwidthControl", !RT_VALID_PTR(aBandwidthControl) ? 0 : *aBandwidthControl, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TracingEnabled)(BOOL *aTracingEnabled)
{
    LogRelFlow(("{%p} %s: enter aTracingEnabled=%p\n", this, "Machine::getTracingEnabled", aTracingEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTracingEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTracingEnabled(aTracingEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGENABLED_RETURN(this, hrc, 0 /*normal*/,*aTracingEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aTracingEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTracingEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTracingEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getTracingEnabled", !RT_VALID_PTR(aTracingEnabled) ? 0 : *aTracingEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TracingEnabled)(BOOL aTracingEnabled)
{
    LogRelFlow(("{%p} %s: enter aTracingEnabled=%RTbool\n", this, "Machine::setTracingEnabled", aTracingEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGENABLED_ENTER(this, aTracingEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTracingEnabled(aTracingEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGENABLED_RETURN(this, hrc, 0 /*normal*/,aTracingEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aTracingEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aTracingEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTracingEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(TracingConfig)(BSTR *aTracingConfig)
{
    LogRelFlow(("{%p} %s: enter aTracingConfig=%p\n", this, "Machine::getTracingConfig", aTracingConfig));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTracingConfig);
        BSTROutConverter TmpTracingConfig(aTracingConfig);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGCONFIG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTracingConfig(TmpTracingConfig.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGCONFIG_RETURN(this, hrc, 0 /*normal*/,TmpTracingConfig.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGCONFIG_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_TRACINGCONFIG_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTracingConfig=%ls hrc=%Rhrc\n", this, "Machine::getTracingConfig", !RT_VALID_PTR(aTracingConfig) ? 0 : *aTracingConfig, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(TracingConfig)(IN_BSTR aTracingConfig)
{
    LogRelFlow(("{%p} %s: enter aTracingConfig=%ls\n", this, "Machine::setTracingConfig", aTracingConfig));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTracingConfig(aTracingConfig);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGCONFIG_ENTER(this, TmpTracingConfig.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTracingConfig(TmpTracingConfig.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGCONFIG_RETURN(this, hrc, 0 /*normal*/,TmpTracingConfig.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGCONFIG_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_TRACINGCONFIG_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setTracingConfig", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AllowTracingToAccessVM)(BOOL *aAllowTracingToAccessVM)
{
    LogRelFlow(("{%p} %s: enter aAllowTracingToAccessVM=%p\n", this, "Machine::getAllowTracingToAccessVM", aAllowTracingToAccessVM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllowTracingToAccessVM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ALLOWTRACINGTOACCESSVM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllowTracingToAccessVM(aAllowTracingToAccessVM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 0 /*normal*/,*aAllowTracingToAccessVM != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 1 /*hrc exception*/,*aAllowTracingToAccessVM != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllowTracingToAccessVM != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllowTracingToAccessVM=%RTbool hrc=%Rhrc\n", this, "Machine::getAllowTracingToAccessVM", !RT_VALID_PTR(aAllowTracingToAccessVM) ? 0 : *aAllowTracingToAccessVM, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(AllowTracingToAccessVM)(BOOL aAllowTracingToAccessVM)
{
    LogRelFlow(("{%p} %s: enter aAllowTracingToAccessVM=%RTbool\n", this, "Machine::setAllowTracingToAccessVM", aAllowTracingToAccessVM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ALLOWTRACINGTOACCESSVM_ENTER(this, aAllowTracingToAccessVM != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAllowTracingToAccessVM(aAllowTracingToAccessVM != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 0 /*normal*/,aAllowTracingToAccessVM != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 1 /*hrc exception*/,aAllowTracingToAccessVM != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_ALLOWTRACINGTOACCESSVM_RETURN(this, hrc, 9 /*unhandled exception*/,aAllowTracingToAccessVM != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setAllowTracingToAccessVM", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AutostartEnabled)(BOOL *aAutostartEnabled)
{
    LogRelFlow(("{%p} %s: enter aAutostartEnabled=%p\n", this, "Machine::getAutostartEnabled", aAutostartEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutostartEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutostartEnabled(aAutostartEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTENABLED_RETURN(this, hrc, 0 /*normal*/,*aAutostartEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aAutostartEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutostartEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutostartEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::getAutostartEnabled", !RT_VALID_PTR(aAutostartEnabled) ? 0 : *aAutostartEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(AutostartEnabled)(BOOL aAutostartEnabled)
{
    LogRelFlow(("{%p} %s: enter aAutostartEnabled=%RTbool\n", this, "Machine::setAutostartEnabled", aAutostartEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTENABLED_ENTER(this, aAutostartEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutostartEnabled(aAutostartEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTENABLED_RETURN(this, hrc, 0 /*normal*/,aAutostartEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aAutostartEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aAutostartEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setAutostartEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AutostartDelay)(ULONG *aAutostartDelay)
{
    LogRelFlow(("{%p} %s: enter aAutostartDelay=%p\n", this, "Machine::getAutostartDelay", aAutostartDelay));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutostartDelay);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTDELAY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutostartDelay(aAutostartDelay);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTDELAY_RETURN(this, hrc, 0 /*normal*/,*aAutostartDelay);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTDELAY_RETURN(this, hrc, 1 /*hrc exception*/,*aAutostartDelay);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTARTDELAY_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutostartDelay);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutostartDelay=%RU32 hrc=%Rhrc\n", this, "Machine::getAutostartDelay", !RT_VALID_PTR(aAutostartDelay) ? 0 : *aAutostartDelay, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(AutostartDelay)(ULONG aAutostartDelay)
{
    LogRelFlow(("{%p} %s: enter aAutostartDelay=%RU32\n", this, "Machine::setAutostartDelay", aAutostartDelay));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTDELAY_ENTER(this, aAutostartDelay);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutostartDelay(aAutostartDelay);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTDELAY_RETURN(this, hrc, 0 /*normal*/,aAutostartDelay);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTDELAY_RETURN(this, hrc, 1 /*hrc exception*/,aAutostartDelay);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTARTDELAY_RETURN(this, hrc, 9 /*unhandled exception*/,aAutostartDelay);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setAutostartDelay", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(AutostopType)(AutostopType_T *aAutostopType)
{
    LogRelFlow(("{%p} %s: enter aAutostopType=%p\n", this, "Machine::getAutostopType", aAutostopType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutostopType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTOPTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutostopType(aAutostopType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTOPTYPE_RETURN(this, hrc, 0 /*normal*/,*aAutostopType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTOPTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAutostopType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_AUTOSTOPTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutostopType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutostopType=%RU32 hrc=%Rhrc\n", this, "Machine::getAutostopType", !RT_VALID_PTR(aAutostopType) ? 0 : *aAutostopType, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(AutostopType)(AutostopType_T aAutostopType)
{
    LogRelFlow(("{%p} %s: enter aAutostopType=%RU32\n", this, "Machine::setAutostopType", aAutostopType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTOPTYPE_ENTER(this, aAutostopType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutostopType(aAutostopType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTOPTYPE_RETURN(this, hrc, 0 /*normal*/,aAutostopType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTOPTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aAutostopType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_AUTOSTOPTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aAutostopType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setAutostopType", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(DefaultFrontend)(BSTR *aDefaultFrontend)
{
    LogRelFlow(("{%p} %s: enter aDefaultFrontend=%p\n", this, "Machine::getDefaultFrontend", aDefaultFrontend));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultFrontend);
        BSTROutConverter TmpDefaultFrontend(aDefaultFrontend);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DEFAULTFRONTEND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultFrontend(TmpDefaultFrontend.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DEFAULTFRONTEND_RETURN(this, hrc, 0 /*normal*/,TmpDefaultFrontend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DEFAULTFRONTEND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_DEFAULTFRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultFrontend=%ls hrc=%Rhrc\n", this, "Machine::getDefaultFrontend", !RT_VALID_PTR(aDefaultFrontend) ? 0 : *aDefaultFrontend, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(DefaultFrontend)(IN_BSTR aDefaultFrontend)
{
    LogRelFlow(("{%p} %s: enter aDefaultFrontend=%ls\n", this, "Machine::setDefaultFrontend", aDefaultFrontend));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpDefaultFrontend(aDefaultFrontend);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DEFAULTFRONTEND_ENTER(this, TmpDefaultFrontend.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultFrontend(TmpDefaultFrontend.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DEFAULTFRONTEND_RETURN(this, hrc, 0 /*normal*/,TmpDefaultFrontend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DEFAULTFRONTEND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_DEFAULTFRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setDefaultFrontend", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(USBProxyAvailable)(BOOL *aUSBProxyAvailable)
{
    LogRelFlow(("{%p} %s: enter aUSBProxyAvailable=%p\n", this, "Machine::getUSBProxyAvailable", aUSBProxyAvailable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBProxyAvailable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBPROXYAVAILABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBProxyAvailable(aUSBProxyAvailable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBPROXYAVAILABLE_RETURN(this, hrc, 0 /*normal*/,*aUSBProxyAvailable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBPROXYAVAILABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aUSBProxyAvailable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_USBPROXYAVAILABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUSBProxyAvailable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUSBProxyAvailable=%RTbool hrc=%Rhrc\n", this, "Machine::getUSBProxyAvailable", !RT_VALID_PTR(aUSBProxyAvailable) ? 0 : *aUSBProxyAvailable, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(VMProcessPriority)(VMProcPriority_T *aVMProcessPriority)
{
    LogRelFlow(("{%p} %s: enter aVMProcessPriority=%p\n", this, "Machine::getVMProcessPriority", aVMProcessPriority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVMProcessPriority);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMPROCESSPRIORITY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVMProcessPriority(aVMProcessPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMPROCESSPRIORITY_RETURN(this, hrc, 0 /*normal*/,*aVMProcessPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMPROCESSPRIORITY_RETURN(this, hrc, 1 /*hrc exception*/,*aVMProcessPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMPROCESSPRIORITY_RETURN(this, hrc, 9 /*unhandled exception*/,*aVMProcessPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVMProcessPriority=%RU32 hrc=%Rhrc\n", this, "Machine::getVMProcessPriority", !RT_VALID_PTR(aVMProcessPriority) ? 0 : *aVMProcessPriority, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(VMProcessPriority)(VMProcPriority_T aVMProcessPriority)
{
    LogRelFlow(("{%p} %s: enter aVMProcessPriority=%RU32\n", this, "Machine::setVMProcessPriority", aVMProcessPriority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMPROCESSPRIORITY_ENTER(this, aVMProcessPriority);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVMProcessPriority(aVMProcessPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMPROCESSPRIORITY_RETURN(this, hrc, 0 /*normal*/,aVMProcessPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMPROCESSPRIORITY_RETURN(this, hrc, 1 /*hrc exception*/,aVMProcessPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMPROCESSPRIORITY_RETURN(this, hrc, 9 /*unhandled exception*/,aVMProcessPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setVMProcessPriority", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(VMExecutionEngine)(VMExecutionEngine_T *aVMExecutionEngine)
{
    LogRelFlow(("{%p} %s: enter aVMExecutionEngine=%p\n", this, "Machine::getVMExecutionEngine", aVMExecutionEngine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVMExecutionEngine);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMEXECUTIONENGINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVMExecutionEngine(aVMExecutionEngine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMEXECUTIONENGINE_RETURN(this, hrc, 0 /*normal*/,*aVMExecutionEngine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMEXECUTIONENGINE_RETURN(this, hrc, 1 /*hrc exception*/,*aVMExecutionEngine);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_VMEXECUTIONENGINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVMExecutionEngine);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVMExecutionEngine=%RU32 hrc=%Rhrc\n", this, "Machine::getVMExecutionEngine", !RT_VALID_PTR(aVMExecutionEngine) ? 0 : *aVMExecutionEngine, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(VMExecutionEngine)(VMExecutionEngine_T aVMExecutionEngine)
{
    LogRelFlow(("{%p} %s: enter aVMExecutionEngine=%RU32\n", this, "Machine::setVMExecutionEngine", aVMExecutionEngine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMEXECUTIONENGINE_ENTER(this, aVMExecutionEngine);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVMExecutionEngine(aVMExecutionEngine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMEXECUTIONENGINE_RETURN(this, hrc, 0 /*normal*/,aVMExecutionEngine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMEXECUTIONENGINE_RETURN(this, hrc, 1 /*hrc exception*/,aVMExecutionEngine);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_VMEXECUTIONENGINE_RETURN(this, hrc, 9 /*unhandled exception*/,aVMExecutionEngine);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setVMExecutionEngine", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(ParavirtDebug)(BSTR *aParavirtDebug)
{
    LogRelFlow(("{%p} %s: enter aParavirtDebug=%p\n", this, "Machine::getParavirtDebug", aParavirtDebug));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParavirtDebug);
        BSTROutConverter TmpParavirtDebug(aParavirtDebug);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTDEBUG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParavirtDebug(TmpParavirtDebug.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTDEBUG_RETURN(this, hrc, 0 /*normal*/,TmpParavirtDebug.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTDEBUG_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_PARAVIRTDEBUG_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParavirtDebug=%ls hrc=%Rhrc\n", this, "Machine::getParavirtDebug", !RT_VALID_PTR(aParavirtDebug) ? 0 : *aParavirtDebug, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(ParavirtDebug)(IN_BSTR aParavirtDebug)
{
    LogRelFlow(("{%p} %s: enter aParavirtDebug=%ls\n", this, "Machine::setParavirtDebug", aParavirtDebug));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpParavirtDebug(aParavirtDebug);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTDEBUG_ENTER(this, TmpParavirtDebug.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setParavirtDebug(TmpParavirtDebug.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTDEBUG_RETURN(this, hrc, 0 /*normal*/,TmpParavirtDebug.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTDEBUG_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_PARAVIRTDEBUG_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setParavirtDebug", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(CPUProfile)(BSTR *aCPUProfile)
{
    LogRelFlow(("{%p} %s: enter aCPUProfile=%p\n", this, "Machine::getCPUProfile", aCPUProfile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCPUProfile);
        BSTROutConverter TmpCPUProfile(aCPUProfile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUPROFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUProfile(TmpCPUProfile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUPROFILE_RETURN(this, hrc, 0 /*normal*/,TmpCPUProfile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUPROFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_CPUPROFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCPUProfile=%ls hrc=%Rhrc\n", this, "Machine::getCPUProfile", !RT_VALID_PTR(aCPUProfile) ? 0 : *aCPUProfile, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMSETTER(CPUProfile)(IN_BSTR aCPUProfile)
{
    LogRelFlow(("{%p} %s: enter aCPUProfile=%ls\n", this, "Machine::setCPUProfile", aCPUProfile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpCPUProfile(aCPUProfile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUPROFILE_ENTER(this, TmpCPUProfile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUProfile(TmpCPUProfile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUPROFILE_RETURN(this, hrc, 0 /*normal*/,TmpCPUProfile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUPROFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SET_CPUPROFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setCPUProfile", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(StateKeyId)(BSTR *aStateKeyId)
{
    LogRelFlow(("{%p} %s: enter aStateKeyId=%p\n", this, "Machine::getStateKeyId", aStateKeyId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStateKeyId);
        BSTROutConverter TmpStateKeyId(aStateKeyId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStateKeyId(TmpStateKeyId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYID_RETURN(this, hrc, 0 /*normal*/,TmpStateKeyId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStateKeyId=%ls hrc=%Rhrc\n", this, "Machine::getStateKeyId", !RT_VALID_PTR(aStateKeyId) ? 0 : *aStateKeyId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(StateKeyStore)(BSTR *aStateKeyStore)
{
    LogRelFlow(("{%p} %s: enter aStateKeyStore=%p\n", this, "Machine::getStateKeyStore", aStateKeyStore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStateKeyStore);
        BSTROutConverter TmpStateKeyStore(aStateKeyStore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYSTORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStateKeyStore(TmpStateKeyStore.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYSTORE_RETURN(this, hrc, 0 /*normal*/,TmpStateKeyStore.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYSTORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_STATEKEYSTORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStateKeyStore=%ls hrc=%Rhrc\n", this, "Machine::getStateKeyStore", !RT_VALID_PTR(aStateKeyStore) ? 0 : *aStateKeyStore, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(LogKeyId)(BSTR *aLogKeyId)
{
    LogRelFlow(("{%p} %s: enter aLogKeyId=%p\n", this, "Machine::getLogKeyId", aLogKeyId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogKeyId);
        BSTROutConverter TmpLogKeyId(aLogKeyId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogKeyId(TmpLogKeyId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYID_RETURN(this, hrc, 0 /*normal*/,TmpLogKeyId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogKeyId=%ls hrc=%Rhrc\n", this, "Machine::getLogKeyId", !RT_VALID_PTR(aLogKeyId) ? 0 : *aLogKeyId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(LogKeyStore)(BSTR *aLogKeyStore)
{
    LogRelFlow(("{%p} %s: enter aLogKeyStore=%p\n", this, "Machine::getLogKeyStore", aLogKeyStore));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogKeyStore);
        BSTROutConverter TmpLogKeyStore(aLogKeyStore);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYSTORE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogKeyStore(TmpLogKeyStore.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYSTORE_RETURN(this, hrc, 0 /*normal*/,TmpLogKeyStore.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYSTORE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_LOGKEYSTORE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogKeyStore=%ls hrc=%Rhrc\n", this, "Machine::getLogKeyStore", !RT_VALID_PTR(aLogKeyStore) ? 0 : *aLogKeyStore, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(GuestDebugControl)(IGuestDebugControl **aGuestDebugControl)
{
    LogRelFlow(("{%p} %s: enter aGuestDebugControl=%p\n", this, "Machine::getGuestDebugControl", aGuestDebugControl));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestDebugControl);
        ComTypeOutConverter<IGuestDebugControl> TmpGuestDebugControl(aGuestDebugControl);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GUESTDEBUGCONTROL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestDebugControl(TmpGuestDebugControl.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GUESTDEBUGCONTROL_RETURN(this, hrc, 0 /*normal*/,(void *)TmpGuestDebugControl.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GUESTDEBUGCONTROL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GET_GUESTDEBUGCONTROL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestDebugControl=%p hrc=%Rhrc\n", this, "Machine::getGuestDebugControl", !RT_VALID_PTR(aGuestDebugControl) ? 0 : *aGuestDebugControl, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute1IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute2IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute3IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute4IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute5IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute6IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute7IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute8IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute9IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute10IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute11IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute12IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute13IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute14IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute15IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::COMGETTER(InternalAndReservedAttribute16IMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IInternalMachineControl properties
//


//
// IMachine methods
//

STDMETHODIMP MachineWrap::LockMachine(ISession *aSession,
                                      LockType_T aLockType)
{
    LogRelFlow(("{%p} %s: enter aSession=%p aLockType=%RU32\n", this, "Machine::lockMachine", aSession, aLockType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<ISession> TmpSession(aSession);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMACHINE_ENTER(this, (void *)TmpSession.ptr(), aLockType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = lockMachine(TmpSession.ptr(),
                              aLockType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMACHINE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSession.ptr(), aLockType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLockType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLockType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::lockMachine", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::LaunchVMProcess(ISession *aSession,
                                          IN_BSTR aName,
                                          ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSession=%p aName=%ls aEnvironmentChanges=%zu aProgress=%p\n", this, "Machine::launchVMProcess", aSession, aName, aEnvironmentChanges, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<ISession> TmpSession(aSession);
        BSTRInConverter TmpName(aName);
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LAUNCHVMPROCESS_ENTER(this, (void *)TmpSession.ptr(), TmpName.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = launchVMProcess(TmpSession.ptr(),
                                  TmpName.str(),
                                  TmpEnvironmentChanges.array(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LAUNCHVMPROCESS_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSession.ptr(), TmpName.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LAUNCHVMPROCESS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LAUNCHVMPROCESS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::launchVMProcess", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetBootOrder(ULONG aPosition,
                                       DeviceType_T aDevice)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32 aDevice=%RU32\n", this, "Machine::setBootOrder", aPosition, aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBOOTORDER_ENTER(this, aPosition, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBootOrder(aPosition,
                               aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBOOTORDER_RETURN(this, hrc, 0 /*normal*/, aPosition, aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBOOTORDER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition, aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBOOTORDER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition, aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setBootOrder", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetBootOrder(ULONG aPosition,
                                       DeviceType_T *aDevice)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32 aDevice=%p\n", this, "Machine::getBootOrder", aPosition, aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDevice);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETBOOTORDER_ENTER(this, aPosition);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootOrder(aPosition,
                               aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETBOOTORDER_RETURN(this, hrc, 0 /*normal*/, aPosition, *aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETBOOTORDER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition, *aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETBOOTORDER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition, *aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDevice=%RU32 hrc=%Rhrc\n", this, "Machine::getBootOrder", !RT_VALID_PTR(aDevice) ? 0 : *aDevice, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AttachDevice(IN_BSTR aName,
                                       LONG aControllerPort,
                                       LONG aDevice,
                                       DeviceType_T aType,
                                       IMedium *aMedium)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aType=%RU32 aMedium=%p\n", this, "Machine::attachDevice", aName, aControllerPort, aDevice, aType, aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        
        ComTypeInConverter<IMedium> TmpMedium(aMedium);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aType, (void *)TmpMedium.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = attachDevice(TmpName.str(),
                               aControllerPort,
                               aDevice,
                               aType,
                               TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aType, (void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::attachDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AttachDeviceWithoutMedium(IN_BSTR aName,
                                                    LONG aControllerPort,
                                                    LONG aDevice,
                                                    DeviceType_T aType)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aType=%RU32\n", this, "Machine::attachDeviceWithoutMedium", aName, aControllerPort, aDevice, aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICEWITHOUTMEDIUM_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = attachDeviceWithoutMedium(TmpName.str(),
                                            aControllerPort,
                                            aDevice,
                                            aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICEWITHOUTMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICEWITHOUTMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHDEVICEWITHOUTMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::attachDeviceWithoutMedium", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DetachDevice(IN_BSTR aName,
                                       LONG aControllerPort,
                                       LONG aDevice)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32\n", this, "Machine::detachDevice", aName, aControllerPort, aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachDevice(TmpName.str(),
                               aControllerPort,
                               aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::detachDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::PassthroughDevice(IN_BSTR aName,
                                            LONG aControllerPort,
                                            LONG aDevice,
                                            BOOL aPassthrough)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aPassthrough=%RTbool\n", this, "Machine::passthroughDevice", aName, aControllerPort, aDevice, aPassthrough));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PASSTHROUGHDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aPassthrough != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = passthroughDevice(TmpName.str(),
                                    aControllerPort,
                                    aDevice,
                                    aPassthrough != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PASSTHROUGHDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aPassthrough != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PASSTHROUGHDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aPassthrough != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PASSTHROUGHDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aPassthrough != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::passthroughDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::TemporaryEjectDevice(IN_BSTR aName,
                                               LONG aControllerPort,
                                               LONG aDevice,
                                               BOOL aTemporaryEject)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aTemporaryEject=%RTbool\n", this, "Machine::temporaryEjectDevice", aName, aControllerPort, aDevice, aTemporaryEject));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TEMPORARYEJECTDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aTemporaryEject != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = temporaryEjectDevice(TmpName.str(),
                                       aControllerPort,
                                       aDevice,
                                       aTemporaryEject != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TEMPORARYEJECTDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aTemporaryEject != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TEMPORARYEJECTDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aTemporaryEject != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TEMPORARYEJECTDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aTemporaryEject != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::temporaryEjectDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::NonRotationalDevice(IN_BSTR aName,
                                              LONG aControllerPort,
                                              LONG aDevice,
                                              BOOL aNonRotational)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aNonRotational=%RTbool\n", this, "Machine::nonRotationalDevice", aName, aControllerPort, aDevice, aNonRotational));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_NONROTATIONALDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aNonRotational != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = nonRotationalDevice(TmpName.str(),
                                      aControllerPort,
                                      aDevice,
                                      aNonRotational != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_NONROTATIONALDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aNonRotational != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_NONROTATIONALDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aNonRotational != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_NONROTATIONALDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aNonRotational != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::nonRotationalDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetAutoDiscardForDevice(IN_BSTR aName,
                                                  LONG aControllerPort,
                                                  LONG aDevice,
                                                  BOOL aDiscard)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aDiscard=%RTbool\n", this, "Machine::setAutoDiscardForDevice", aName, aControllerPort, aDevice, aDiscard));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETAUTODISCARDFORDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aDiscard != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutoDiscardForDevice(TmpName.str(),
                                          aControllerPort,
                                          aDevice,
                                          aDiscard != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETAUTODISCARDFORDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aDiscard != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETAUTODISCARDFORDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aDiscard != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETAUTODISCARDFORDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aDiscard != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setAutoDiscardForDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetHotPluggableForDevice(IN_BSTR aName,
                                                   LONG aControllerPort,
                                                   LONG aDevice,
                                                   BOOL aHotPluggable)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aHotPluggable=%RTbool\n", this, "Machine::setHotPluggableForDevice", aName, aControllerPort, aDevice, aHotPluggable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETHOTPLUGGABLEFORDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aHotPluggable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHotPluggableForDevice(TmpName.str(),
                                           aControllerPort,
                                           aDevice,
                                           aHotPluggable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETHOTPLUGGABLEFORDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aHotPluggable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETHOTPLUGGABLEFORDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aHotPluggable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETHOTPLUGGABLEFORDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aHotPluggable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setHotPluggableForDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetBandwidthGroupForDevice(IN_BSTR aName,
                                                     LONG aControllerPort,
                                                     LONG aDevice,
                                                     IBandwidthGroup *aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aBandwidthGroup=%p\n", this, "Machine::setBandwidthGroupForDevice", aName, aControllerPort, aDevice, aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        ComTypeInConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBANDWIDTHGROUPFORDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpBandwidthGroup.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBandwidthGroupForDevice(TmpName.str(),
                                             aControllerPort,
                                             aDevice,
                                             TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setBandwidthGroupForDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetNoBandwidthGroupForDevice(IN_BSTR aName,
                                                       LONG aControllerPort,
                                                       LONG aDevice)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32\n", this, "Machine::setNoBandwidthGroupForDevice", aName, aControllerPort, aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETNOBANDWIDTHGROUPFORDEVICE_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNoBandwidthGroupForDevice(TmpName.str(),
                                               aControllerPort,
                                               aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETNOBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETNOBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETNOBANDWIDTHGROUPFORDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setNoBandwidthGroupForDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::UnmountMedium(IN_BSTR aName,
                                        LONG aControllerPort,
                                        LONG aDevice,
                                        BOOL aForce)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aForce=%RTbool\n", this, "Machine::unmountMedium", aName, aControllerPort, aDevice, aForce));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNMOUNTMEDIUM_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, aForce != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unmountMedium(TmpName.str(),
                                aControllerPort,
                                aDevice,
                                aForce != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNMOUNTMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, aForce != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNMOUNTMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, aForce != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNMOUNTMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, aForce != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::unmountMedium", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::MountMedium(IN_BSTR aName,
                                      LONG aControllerPort,
                                      LONG aDevice,
                                      IMedium *aMedium,
                                      BOOL aForce)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aMedium=%p aForce=%RTbool\n", this, "Machine::mountMedium", aName, aControllerPort, aDevice, aMedium, aForce));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        
        ComTypeInConverter<IMedium> TmpMedium(aMedium);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOUNTMEDIUM_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpMedium.ptr(), aForce != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = mountMedium(TmpName.str(),
                              aControllerPort,
                              aDevice,
                              TmpMedium.ptr(),
                              aForce != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOUNTMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpMedium.ptr(), aForce != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOUNTMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, 0, aForce != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOUNTMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, 0, aForce != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::mountMedium", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetMedium(IN_BSTR aName,
                                    LONG aControllerPort,
                                    LONG aDevice,
                                    IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aMedium=%p\n", this, "Machine::getMedium", aName, aControllerPort, aDevice, aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);


        BSTRInConverter TmpName(aName);
        
        
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUM_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMedium(TmpName.str(),
                            aControllerPort,
                            aDevice,
                            TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUM_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMedium=%p hrc=%Rhrc\n", this, "Machine::getMedium", !RT_VALID_PTR(aMedium) ? 0 : *aMedium, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetMediumAttachmentsOfController(IN_BSTR aName,
                                                           ComSafeArrayOut(IMediumAttachment *, aMediumAttachments))
{
    LogRelFlow(("{%p} %s: enter aName=%ls aMediumAttachments=%p\n", this, "Machine::getMediumAttachmentsOfController", aName, aMediumAttachments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMediumAttachments);


        BSTRInConverter TmpName(aName);
        ArrayComTypeOutConverter<IMediumAttachment> TmpMediumAttachments(ComSafeArrayOutArg(aMediumAttachments));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENTSOFCONTROLLER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumAttachmentsOfController(TmpName.str(),
                                                   TmpMediumAttachments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENTSOFCONTROLLER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (uint32_t)TmpMediumAttachments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENTSOFCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENTSOFCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMediumAttachments=%zu hrc=%Rhrc\n", this, "Machine::getMediumAttachmentsOfController", !RT_VALID_PTR(aMediumAttachments) ? 0 : ComSafeArraySize(*aMediumAttachments), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetMediumAttachment(IN_BSTR aName,
                                              LONG aControllerPort,
                                              LONG aDevice,
                                              IMediumAttachment **aAttachment)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aControllerPort=%RI32 aDevice=%RI32 aAttachment=%p\n", this, "Machine::getMediumAttachment", aName, aControllerPort, aDevice, aAttachment));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAttachment);


        BSTRInConverter TmpName(aName);
        
        
        ComTypeOutConverter<IMediumAttachment> TmpAttachment(aAttachment);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENT_ENTER(this, TmpName.str().c_str(), aControllerPort, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumAttachment(TmpName.str(),
                                      aControllerPort,
                                      aDevice,
                                      TmpAttachment.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aControllerPort, aDevice, (void *)TmpAttachment.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETMEDIUMATTACHMENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aControllerPort, aDevice, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAttachment=%p hrc=%Rhrc\n", this, "Machine::getMediumAttachment", !RT_VALID_PTR(aAttachment) ? 0 : *aAttachment, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AttachHostPCIDevice(LONG aHostAddress,
                                              LONG aDesiredGuestAddress,
                                              BOOL aTryToUnbind)
{
    LogRelFlow(("{%p} %s: enter aHostAddress=%RI32 aDesiredGuestAddress=%RI32 aTryToUnbind=%RTbool\n", this, "Machine::attachHostPCIDevice", aHostAddress, aDesiredGuestAddress, aTryToUnbind));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHHOSTPCIDEVICE_ENTER(this, aHostAddress, aDesiredGuestAddress, aTryToUnbind != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = attachHostPCIDevice(aHostAddress,
                                      aDesiredGuestAddress,
                                      aTryToUnbind != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHHOSTPCIDEVICE_RETURN(this, hrc, 0 /*normal*/, aHostAddress, aDesiredGuestAddress, aTryToUnbind != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHHOSTPCIDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, aHostAddress, aDesiredGuestAddress, aTryToUnbind != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ATTACHHOSTPCIDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, aHostAddress, aDesiredGuestAddress, aTryToUnbind != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::attachHostPCIDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DetachHostPCIDevice(LONG aHostAddress)
{
    LogRelFlow(("{%p} %s: enter aHostAddress=%RI32\n", this, "Machine::detachHostPCIDevice", aHostAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHHOSTPCIDEVICE_ENTER(this, aHostAddress);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachHostPCIDevice(aHostAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHHOSTPCIDEVICE_RETURN(this, hrc, 0 /*normal*/, aHostAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHHOSTPCIDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, aHostAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHHOSTPCIDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, aHostAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::detachHostPCIDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetNetworkAdapter(ULONG aSlot,
                                            INetworkAdapter **aAdapter)
{
    LogRelFlow(("{%p} %s: enter aSlot=%RU32 aAdapter=%p\n", this, "Machine::getNetworkAdapter", aSlot, aAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdapter);


        
        ComTypeOutConverter<INetworkAdapter> TmpAdapter(aAdapter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETNETWORKADAPTER_ENTER(this, aSlot);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkAdapter(aSlot,
                                    TmpAdapter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETNETWORKADAPTER_RETURN(this, hrc, 0 /*normal*/, aSlot, (void *)TmpAdapter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETNETWORKADAPTER_RETURN(this, hrc, 1 /*hrc exception*/, aSlot, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETNETWORKADAPTER_RETURN(this, hrc, 9 /*unhandled exception*/, aSlot, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAdapter=%p hrc=%Rhrc\n", this, "Machine::getNetworkAdapter", !RT_VALID_PTR(aAdapter) ? 0 : *aAdapter, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AddStorageController(IN_BSTR aName,
                                               StorageBus_T aConnectionType,
                                               IStorageController **aController)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aConnectionType=%RU32 aController=%p\n", this, "Machine::addStorageController", aName, aConnectionType, aController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aController);


        BSTRInConverter TmpName(aName);
        
        ComTypeOutConverter<IStorageController> TmpController(aController);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDSTORAGECONTROLLER_ENTER(this, TmpName.str().c_str(), aConnectionType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addStorageController(TmpName.str(),
                                       aConnectionType,
                                       TmpController.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDSTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aConnectionType, (void *)TmpController.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDSTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/, 0, aConnectionType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDSTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aConnectionType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aController=%p hrc=%Rhrc\n", this, "Machine::addStorageController", !RT_VALID_PTR(aController) ? 0 : *aController, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetStorageControllerByName(IN_BSTR aName,
                                                     IStorageController **aStorageController)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aStorageController=%p\n", this, "Machine::getStorageControllerByName", aName, aStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStorageController);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IStorageController> TmpStorageController(aStorageController);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYNAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStorageControllerByName(TmpName.str(),
                                             TmpStorageController.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpStorageController.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aStorageController=%p hrc=%Rhrc\n", this, "Machine::getStorageControllerByName", !RT_VALID_PTR(aStorageController) ? 0 : *aStorageController, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetStorageControllerByInstance(StorageBus_T aConnectionType,
                                                         ULONG aInstance,
                                                         IStorageController **aStorageController)
{
    LogRelFlow(("{%p} %s: enter aConnectionType=%RU32 aInstance=%RU32 aStorageController=%p\n", this, "Machine::getStorageControllerByInstance", aConnectionType, aInstance, aStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStorageController);


        
        
        ComTypeOutConverter<IStorageController> TmpStorageController(aStorageController);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYINSTANCE_ENTER(this, aConnectionType, aInstance);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStorageControllerByInstance(aConnectionType,
                                                 aInstance,
                                                 TmpStorageController.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYINSTANCE_RETURN(this, hrc, 0 /*normal*/, aConnectionType, aInstance, (void *)TmpStorageController.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, aConnectionType, aInstance, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSTORAGECONTROLLERBYINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, aConnectionType, aInstance, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aStorageController=%p hrc=%Rhrc\n", this, "Machine::getStorageControllerByInstance", !RT_VALID_PTR(aStorageController) ? 0 : *aStorageController, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RemoveStorageController(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Machine::removeStorageController", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESTORAGECONTROLLER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeStorageController(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::removeStorageController", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetStorageControllerBootable(IN_BSTR aName,
                                                       BOOL aBootable)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aBootable=%RTbool\n", this, "Machine::setStorageControllerBootable", aName, aBootable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSTORAGECONTROLLERBOOTABLE_ENTER(this, TmpName.str().c_str(), aBootable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setStorageControllerBootable(TmpName.str(),
                                               aBootable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSTORAGECONTROLLERBOOTABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aBootable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSTORAGECONTROLLERBOOTABLE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aBootable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSTORAGECONTROLLERBOOTABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aBootable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setStorageControllerBootable", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AddUSBController(IN_BSTR aName,
                                           USBControllerType_T aType,
                                           IUSBController **aController)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aType=%RU32 aController=%p\n", this, "Machine::addUSBController", aName, aType, aController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aController);


        BSTRInConverter TmpName(aName);
        
        ComTypeOutConverter<IUSBController> TmpController(aController);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDUSBCONTROLLER_ENTER(this, TmpName.str().c_str(), aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addUSBController(TmpName.str(),
                                   aType,
                                   TmpController.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDUSBCONTROLLER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aType, (void *)TmpController.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDUSBCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/, 0, aType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDUSBCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aController=%p hrc=%Rhrc\n", this, "Machine::addUSBController", !RT_VALID_PTR(aController) ? 0 : *aController, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RemoveUSBController(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Machine::removeUSBController", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEUSBCONTROLLER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeUSBController(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEUSBCONTROLLER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEUSBCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEUSBCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::removeUSBController", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetUSBControllerByName(IN_BSTR aName,
                                                 IUSBController **aController)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aController=%p\n", this, "Machine::getUSBControllerByName", aName, aController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aController);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IUSBController> TmpController(aController);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERBYNAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBControllerByName(TmpName.str(),
                                         TmpController.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpController.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aController=%p hrc=%Rhrc\n", this, "Machine::getUSBControllerByName", !RT_VALID_PTR(aController) ? 0 : *aController, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetUSBControllerCountByType(USBControllerType_T aType,
                                                      ULONG *aControllers)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aControllers=%p\n", this, "Machine::getUSBControllerCountByType", aType, aControllers));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aControllers);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERCOUNTBYTYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBControllerCountByType(aType,
                                              aControllers);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERCOUNTBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType, *aControllers);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERCOUNTBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType, *aControllers);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETUSBCONTROLLERCOUNTBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, *aControllers);
#endif
    }

    LogRelFlow(("{%p} %s: leave aControllers=%RU32 hrc=%Rhrc\n", this, "Machine::getUSBControllerCountByType", !RT_VALID_PTR(aControllers) ? 0 : *aControllers, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetSerialPort(ULONG aSlot,
                                        ISerialPort **aPort)
{
    LogRelFlow(("{%p} %s: enter aSlot=%RU32 aPort=%p\n", this, "Machine::getSerialPort", aSlot, aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);


        
        ComTypeOutConverter<ISerialPort> TmpPort(aPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSERIALPORT_ENTER(this, aSlot);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialPort(aSlot,
                                TmpPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSERIALPORT_RETURN(this, hrc, 0 /*normal*/, aSlot, (void *)TmpPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSERIALPORT_RETURN(this, hrc, 1 /*hrc exception*/, aSlot, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETSERIALPORT_RETURN(this, hrc, 9 /*unhandled exception*/, aSlot, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aPort=%p hrc=%Rhrc\n", this, "Machine::getSerialPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetParallelPort(ULONG aSlot,
                                          IParallelPort **aPort)
{
    LogRelFlow(("{%p} %s: enter aSlot=%RU32 aPort=%p\n", this, "Machine::getParallelPort", aSlot, aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);


        
        ComTypeOutConverter<IParallelPort> TmpPort(aPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETPARALLELPORT_ENTER(this, aSlot);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParallelPort(aSlot,
                                  TmpPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETPARALLELPORT_RETURN(this, hrc, 0 /*normal*/, aSlot, (void *)TmpPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETPARALLELPORT_RETURN(this, hrc, 1 /*hrc exception*/, aSlot, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETPARALLELPORT_RETURN(this, hrc, 9 /*unhandled exception*/, aSlot, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aPort=%p hrc=%Rhrc\n", this, "Machine::getParallelPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
{
    LogRelFlow(("{%p} %s: enter aKeys=%p\n", this, "Machine::getExtraDataKeys", aKeys));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeys);


        ArrayBSTROutConverter TmpKeys(ComSafeArrayOutArg(aKeys));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATAKEYS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtraDataKeys(TmpKeys.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATAKEYS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpKeys.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATAKEYS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATAKEYS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aKeys=%zu hrc=%Rhrc\n", this, "Machine::getExtraDataKeys", !RT_VALID_PTR(aKeys) ? 0 : ComSafeArraySize(*aKeys), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetExtraData(IN_BSTR aKey,
                                       BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "Machine::getExtraData", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpKey(aKey);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATA_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtraData(TmpKey.str(),
                               TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATA_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEXTRADATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "Machine::getExtraData", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetExtraData(IN_BSTR aKey,
                                       IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%ls\n", this, "Machine::setExtraData", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpKey(aKey);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETEXTRADATA_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setExtraData(TmpKey.str(),
                               TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETEXTRADATA_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETEXTRADATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETEXTRADATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setExtraData", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetSettingsFilePath(IN_BSTR aSettingsFilePath,
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSettingsFilePath=%ls aProgress=%p\n", this, "Machine::setSettingsFilePath", aSettingsFilePath, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSettingsFilePath(aSettingsFilePath);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSETTINGSFILEPATH_ENTER(this, TmpSettingsFilePath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSettingsFilePath(TmpSettingsFilePath.str(),
                                      TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSETTINGSFILEPATH_RETURN(this, hrc, 0 /*normal*/, TmpSettingsFilePath.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSETTINGSFILEPATH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETSETTINGSFILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::setSettingsFilePath", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SaveSettings()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::saveSettings"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = saveSettings();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESETTINGS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESETTINGS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::saveSettings", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DiscardSettings()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::discardSettings"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = discardSettings();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSETTINGS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::discardSettings", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::Unregister(CleanupMode_T aCleanupMode,
                                     ComSafeArrayOut(IMedium *, aMedia))
{
    LogRelFlow(("{%p} %s: enter aCleanupMode=%RU32 aMedia=%p\n", this, "Machine::unregister", aCleanupMode, aMedia));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedia);


        
        ArrayComTypeOutConverter<IMedium> TmpMedia(ComSafeArrayOutArg(aMedia));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNREGISTER_ENTER(this, aCleanupMode);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unregister(autoCaller,
                         aCleanupMode,
                             TmpMedia.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNREGISTER_RETURN(this, hrc, 0 /*normal*/, aCleanupMode, (uint32_t)TmpMedia.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNREGISTER_RETURN(this, hrc, 1 /*hrc exception*/, aCleanupMode, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNREGISTER_RETURN(this, hrc, 9 /*unhandled exception*/, aCleanupMode, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMedia=%zu hrc=%Rhrc\n", this, "Machine::unregister", !RT_VALID_PTR(aMedia) ? 0 : ComSafeArraySize(*aMedia), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DeleteConfig(ComSafeArrayIn(IMedium *, aMedia),
                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aMedia=%zu aProgress=%p\n", this, "Machine::deleteConfig", aMedia, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayComTypeInConverter<IMedium> TmpMedia(ComSafeArrayInArg(aMedia));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETECONFIG_ENTER(this, (uint32_t)TmpMedia.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteConfig(TmpMedia.array(),
                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETECONFIG_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMedia.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETECONFIG_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETECONFIG_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::deleteConfig", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ExportTo(IAppliance *aAppliance,
                                   IN_BSTR aLocation,
                                   IVirtualSystemDescription **aDescription)
{
    LogRelFlow(("{%p} %s: enter aAppliance=%p aLocation=%ls aDescription=%p\n", this, "Machine::exportTo", aAppliance, aLocation, aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);


        ComTypeInConverter<IAppliance> TmpAppliance(aAppliance);
        BSTRInConverter TmpLocation(aLocation);
        ComTypeOutConverter<IVirtualSystemDescription> TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EXPORTTO_ENTER(this, (void *)TmpAppliance.ptr(), TmpLocation.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = exportTo(TmpAppliance.ptr(),
                           TmpLocation.str(),
                           TmpDescription.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EXPORTTO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpAppliance.ptr(), TmpLocation.str().c_str(), (void *)TmpDescription.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EXPORTTO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EXPORTTO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDescription=%p hrc=%Rhrc\n", this, "Machine::exportTo", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::FindSnapshot(IN_BSTR aNameOrId,
                                       ISnapshot **aSnapshot)
{
    LogRelFlow(("{%p} %s: enter aNameOrId=%ls aSnapshot=%p\n", this, "Machine::findSnapshot", aNameOrId, aSnapshot));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSnapshot);


        BSTRInConverter TmpNameOrId(aNameOrId);
        ComTypeOutConverter<ISnapshot> TmpSnapshot(aSnapshot);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINDSNAPSHOT_ENTER(this, TmpNameOrId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findSnapshot(TmpNameOrId.str(),
                               TmpSnapshot.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINDSNAPSHOT_RETURN(this, hrc, 0 /*normal*/, TmpNameOrId.str().c_str(), (void *)TmpSnapshot.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINDSNAPSHOT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINDSNAPSHOT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSnapshot=%p hrc=%Rhrc\n", this, "Machine::findSnapshot", !RT_VALID_PTR(aSnapshot) ? 0 : *aSnapshot, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::CreateSharedFolder(IN_BSTR aName,
                                             IN_BSTR aHostPath,
                                             BOOL aWritable,
                                             BOOL aAutomount,
                                             IN_BSTR aAutoMountPoint)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aHostPath=%ls aWritable=%RTbool aAutomount=%RTbool aAutoMountPoint=%ls\n", this, "Machine::createSharedFolder", aName, aHostPath, aWritable, aAutomount, aAutoMountPoint));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpHostPath(aHostPath);
        
        
        BSTRInConverter TmpAutoMountPoint(aAutoMountPoint);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CREATESHAREDFOLDER_ENTER(this, TmpName.str().c_str(), TmpHostPath.str().c_str(), aWritable != FALSE, aAutomount != FALSE, TmpAutoMountPoint.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createSharedFolder(TmpName.str(),
                                     TmpHostPath.str(),
                                     aWritable != FALSE,
                                     aAutomount != FALSE,
                                     TmpAutoMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CREATESHAREDFOLDER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpHostPath.str().c_str(), aWritable != FALSE, aAutomount != FALSE, TmpAutoMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CREATESHAREDFOLDER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aWritable != FALSE, aAutomount != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CREATESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aWritable != FALSE, aAutomount != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::createSharedFolder", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RemoveSharedFolder(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Machine::removeSharedFolder", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESHAREDFOLDER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeSharedFolder(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESHAREDFOLDER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESHAREDFOLDER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::removeSharedFolder", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::CanShowConsoleWindow(BOOL *aCanShow)
{
    LogRelFlow(("{%p} %s: enter aCanShow=%p\n", this, "Machine::canShowConsoleWindow", aCanShow));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCanShow);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CANSHOWCONSOLEWINDOW_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = canShowConsoleWindow(aCanShow);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CANSHOWCONSOLEWINDOW_RETURN(this, hrc, 0 /*normal*/, *aCanShow != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CANSHOWCONSOLEWINDOW_RETURN(this, hrc, 1 /*hrc exception*/, *aCanShow != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CANSHOWCONSOLEWINDOW_RETURN(this, hrc, 9 /*unhandled exception*/, *aCanShow != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCanShow=%RTbool hrc=%Rhrc\n", this, "Machine::canShowConsoleWindow", !RT_VALID_PTR(aCanShow) ? 0 : *aCanShow, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ShowConsoleWindow(LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s: enter aWinId=%p\n", this, "Machine::showConsoleWindow", aWinId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWinId);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SHOWCONSOLEWINDOW_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = showConsoleWindow(aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SHOWCONSOLEWINDOW_RETURN(this, hrc, 0 /*normal*/, *aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SHOWCONSOLEWINDOW_RETURN(this, hrc, 1 /*hrc exception*/, *aWinId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SHOWCONSOLEWINDOW_RETURN(this, hrc, 9 /*unhandled exception*/, *aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWinId=%RI64 hrc=%Rhrc\n", this, "Machine::showConsoleWindow", !RT_VALID_PTR(aWinId) ? 0 : *aWinId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetGuestProperty(IN_BSTR aName,
                                           BSTR *aValue,
                                           LONG64 *aTimestamp,
                                           BSTR *aFlags)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%p aTimestamp=%p aFlags=%p\n", this, "Machine::getGuestProperty", aName, aValue, aTimestamp, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);
        CheckComArgOutPointerValidThrow(aTimestamp);
        CheckComArgOutPointerValidThrow(aFlags);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpValue(aValue);
        
        BSTROutConverter TmpFlags(aFlags);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTY_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestProperty(TmpName.str(),
                                   TmpValue.str(),
                                   aTimestamp,
                                   TmpFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str(), *aTimestamp, TmpFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, *aTimestamp, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, *aTimestamp, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValue=%ls *aTimestamp=%RI64 *aFlags=%ls hrc=%Rhrc\n", this, "Machine::getGuestProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, !RT_VALID_PTR(aTimestamp) ? 0 : *aTimestamp, !RT_VALID_PTR(aFlags) ? 0 : *aFlags, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetGuestPropertyValue(IN_BSTR aProperty,
                                                BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%ls aValue=%p\n", this, "Machine::getGuestPropertyValue", aProperty, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpProperty(aProperty);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYVALUE_ENTER(this, TmpProperty.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestPropertyValue(TmpProperty.str(),
                                        TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYVALUE_RETURN(this, hrc, 0 /*normal*/, TmpProperty.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYVALUE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYVALUE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "Machine::getGuestPropertyValue", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetGuestPropertyTimestamp(IN_BSTR aProperty,
                                                    LONG64 *aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%ls aValue=%p\n", this, "Machine::getGuestPropertyTimestamp", aProperty, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpProperty(aProperty);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYTIMESTAMP_ENTER(this, TmpProperty.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestPropertyTimestamp(TmpProperty.str(),
                                            aValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYTIMESTAMP_RETURN(this, hrc, 0 /*normal*/, TmpProperty.str().c_str(), *aValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYTIMESTAMP_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETGUESTPROPERTYTIMESTAMP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%RI64 hrc=%Rhrc\n", this, "Machine::getGuestPropertyTimestamp", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetGuestProperty(IN_BSTR aProperty,
                                           IN_BSTR aValue,
                                           IN_BSTR aFlags)
{
    LogRelFlow(("{%p} %s: enter aProperty=%ls aValue=%ls aFlags=%ls\n", this, "Machine::setGuestProperty", aProperty, aValue, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpProperty(aProperty);
        BSTRInConverter TmpValue(aValue);
        BSTRInConverter TmpFlags(aFlags);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTY_ENTER(this, TmpProperty.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setGuestProperty(TmpProperty.str(),
                                   TmpValue.str(),
                                   TmpFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpProperty.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setGuestProperty", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SetGuestPropertyValue(IN_BSTR aProperty,
                                                IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%ls aValue=%ls\n", this, "Machine::setGuestPropertyValue", aProperty, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpProperty(aProperty);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTYVALUE_ENTER(this, TmpProperty.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setGuestPropertyValue(TmpProperty.str(),
                                        TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTYVALUE_RETURN(this, hrc, 0 /*normal*/, TmpProperty.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTYVALUE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SETGUESTPROPERTYVALUE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::setGuestPropertyValue", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DeleteGuestProperty(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Machine::deleteGuestProperty", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETEGUESTPROPERTY_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteGuestProperty(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETEGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETEGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETEGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::deleteGuestProperty", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::EnumerateGuestProperties(IN_BSTR aPatterns,
                                                   ComSafeArrayOut(BSTR, aNames),
                                                   ComSafeArrayOut(BSTR, aValues),
                                                   ComSafeArrayOut(LONG64, aTimestamps),
                                                   ComSafeArrayOut(BSTR, aFlags))
{
    LogRelFlow(("{%p} %s: enter aPatterns=%ls aNames=%p aValues=%p aTimestamps=%p aFlags=%p\n", this, "Machine::enumerateGuestProperties", aPatterns, aNames, aValues, aTimestamps, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNames);
        CheckComArgOutPointerValidThrow(aValues);
        CheckComArgOutPointerValidThrow(aTimestamps);
        CheckComArgOutPointerValidThrow(aFlags);


        BSTRInConverter TmpPatterns(aPatterns);
        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));
        ArrayOutConverter<LONG64> TmpTimestamps(ComSafeArrayOutArg(aTimestamps));
        ArrayBSTROutConverter TmpFlags(ComSafeArrayOutArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENUMERATEGUESTPROPERTIES_ENTER(this, TmpPatterns.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enumerateGuestProperties(TmpPatterns.str(),
                                           TmpNames.array(),
                                           TmpValues.array(),
                                           TmpTimestamps.array(),
                                           TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 0 /*normal*/, TmpPatterns.str().c_str(), (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/, (uint32_t)TmpTimestamps.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aValues=%zu *aTimestamps=%zu *aFlags=%zu hrc=%Rhrc\n", this, "Machine::enumerateGuestProperties", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), !RT_VALID_PTR(aTimestamps) ? 0 : ComSafeArraySize(*aTimestamps), !RT_VALID_PTR(aFlags) ? 0 : ComSafeArraySize(*aFlags), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::QuerySavedGuestScreenInfo(ULONG aScreenId,
                                                    ULONG *aOriginX,
                                                    ULONG *aOriginY,
                                                    ULONG *aWidth,
                                                    ULONG *aHeight,
                                                    BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aOriginX=%p aOriginY=%p aWidth=%p aHeight=%p aEnabled=%p\n", this, "Machine::querySavedGuestScreenInfo", aScreenId, aOriginX, aOriginY, aWidth, aHeight, aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOriginX);
        CheckComArgOutPointerValidThrow(aOriginY);
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aEnabled);


        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDGUESTSCREENINFO_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySavedGuestScreenInfo(aScreenId,
                                            aOriginX,
                                            aOriginY,
                                            aWidth,
                                            aHeight,
                                            aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDGUESTSCREENINFO_RETURN(this, hrc, 0 /*normal*/, aScreenId, *aOriginX, *aOriginY, *aWidth, *aHeight, *aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDGUESTSCREENINFO_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, *aOriginX, *aOriginY, *aWidth, *aHeight, *aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDGUESTSCREENINFO_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, *aOriginX, *aOriginY, *aWidth, *aHeight, *aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOriginX=%RU32 *aOriginY=%RU32 *aWidth=%RU32 *aHeight=%RU32 *aEnabled=%RTbool hrc=%Rhrc\n", this, "Machine::querySavedGuestScreenInfo", !RT_VALID_PTR(aOriginX) ? 0 : *aOriginX, !RT_VALID_PTR(aOriginY) ? 0 : *aOriginY, !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ReadSavedThumbnailToArray(ULONG aScreenId,
                                                    BitmapFormat_T aBitmapFormat,
                                                    ULONG *aWidth,
                                                    ULONG *aHeight,
                                                    ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aBitmapFormat=%RU32 aWidth=%p aHeight=%p aData=%p\n", this, "Machine::readSavedThumbnailToArray", aScreenId, aBitmapFormat, aWidth, aHeight, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDTHUMBNAILTOARRAY_ENTER(this, aScreenId, aBitmapFormat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readSavedThumbnailToArray(aScreenId,
                                            aBitmapFormat,
                                            aWidth,
                                            aHeight,
                                            TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDTHUMBNAILTOARRAY_RETURN(this, hrc, 0 /*normal*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDTHUMBNAILTOARRAY_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDTHUMBNAILTOARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 *aHeight=%RU32 aData=%zu hrc=%Rhrc\n", this, "Machine::readSavedThumbnailToArray", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::QuerySavedScreenshotInfo(ULONG aScreenId,
                                                   ULONG *aWidth,
                                                   ULONG *aHeight,
                                                   ComSafeArrayOut(BitmapFormat_T, aBitmapFormats))
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aWidth=%p aHeight=%p aBitmapFormats=%p\n", this, "Machine::querySavedScreenshotInfo", aScreenId, aWidth, aHeight, aBitmapFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aBitmapFormats);


        
        
        
        ArrayOutConverter<BitmapFormat_T> TmpBitmapFormats(ComSafeArrayOutArg(aBitmapFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDSCREENSHOTINFO_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySavedScreenshotInfo(aScreenId,
                                           aWidth,
                                           aHeight,
                                           TmpBitmapFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDSCREENSHOTINFO_RETURN(this, hrc, 0 /*normal*/, aScreenId, *aWidth, *aHeight, (uint32_t)TmpBitmapFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDSCREENSHOTINFO_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, *aWidth, *aHeight, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYSAVEDSCREENSHOTINFO_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, *aWidth, *aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 *aHeight=%RU32 aBitmapFormats=%zu hrc=%Rhrc\n", this, "Machine::querySavedScreenshotInfo", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aBitmapFormats) ? 0 : ComSafeArraySize(*aBitmapFormats), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ReadSavedScreenshotToArray(ULONG aScreenId,
                                                     BitmapFormat_T aBitmapFormat,
                                                     ULONG *aWidth,
                                                     ULONG *aHeight,
                                                     ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aBitmapFormat=%RU32 aWidth=%p aHeight=%p aData=%p\n", this, "Machine::readSavedScreenshotToArray", aScreenId, aBitmapFormat, aWidth, aHeight, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDSCREENSHOTTOARRAY_ENTER(this, aScreenId, aBitmapFormat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readSavedScreenshotToArray(aScreenId,
                                             aBitmapFormat,
                                             aWidth,
                                             aHeight,
                                             TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDSCREENSHOTTOARRAY_RETURN(this, hrc, 0 /*normal*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDSCREENSHOTTOARRAY_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READSAVEDSCREENSHOTTOARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aBitmapFormat, *aWidth, *aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 *aHeight=%RU32 aData=%zu hrc=%Rhrc\n", this, "Machine::readSavedScreenshotToArray", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::HotPlugCPU(ULONG aCpu)
{
    LogRelFlow(("{%p} %s: enter aCpu=%RU32\n", this, "Machine::hotPlugCPU", aCpu));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTPLUGCPU_ENTER(this, aCpu);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = hotPlugCPU(aCpu);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTPLUGCPU_RETURN(this, hrc, 0 /*normal*/, aCpu);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTPLUGCPU_RETURN(this, hrc, 1 /*hrc exception*/, aCpu);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTPLUGCPU_RETURN(this, hrc, 9 /*unhandled exception*/, aCpu);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::hotPlugCPU", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::HotUnplugCPU(ULONG aCpu)
{
    LogRelFlow(("{%p} %s: enter aCpu=%RU32\n", this, "Machine::hotUnplugCPU", aCpu));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTUNPLUGCPU_ENTER(this, aCpu);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = hotUnplugCPU(aCpu);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTUNPLUGCPU_RETURN(this, hrc, 0 /*normal*/, aCpu);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTUNPLUGCPU_RETURN(this, hrc, 1 /*hrc exception*/, aCpu);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_HOTUNPLUGCPU_RETURN(this, hrc, 9 /*unhandled exception*/, aCpu);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::hotUnplugCPU", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetCPUStatus(ULONG aCpu,
                                       BOOL *aAttached)
{
    LogRelFlow(("{%p} %s: enter aCpu=%RU32 aAttached=%p\n", this, "Machine::getCPUStatus", aCpu, aAttached));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAttached);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETCPUSTATUS_ENTER(this, aCpu);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUStatus(aCpu,
                               aAttached);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETCPUSTATUS_RETURN(this, hrc, 0 /*normal*/, aCpu, *aAttached != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETCPUSTATUS_RETURN(this, hrc, 1 /*hrc exception*/, aCpu, *aAttached != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETCPUSTATUS_RETURN(this, hrc, 9 /*unhandled exception*/, aCpu, *aAttached != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAttached=%RTbool hrc=%Rhrc\n", this, "Machine::getCPUStatus", !RT_VALID_PTR(aAttached) ? 0 : *aAttached, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider)
{
    LogRelFlow(("{%p} %s: enter aParavirtProvider=%p\n", this, "Machine::getEffectiveParavirtProvider", aParavirtProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParavirtProvider);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEFFECTIVEPARAVIRTPROVIDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEffectiveParavirtProvider(aParavirtProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEFFECTIVEPARAVIRTPROVIDER_RETURN(this, hrc, 0 /*normal*/, *aParavirtProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEFFECTIVEPARAVIRTPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/, *aParavirtProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETEFFECTIVEPARAVIRTPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/, *aParavirtProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave aParavirtProvider=%RU32 hrc=%Rhrc\n", this, "Machine::getEffectiveParavirtProvider", !RT_VALID_PTR(aParavirtProvider) ? 0 : *aParavirtProvider, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::QueryLogFilename(ULONG aIdx,
                                           BSTR *aFilename)
{
    LogRelFlow(("{%p} %s: enter aIdx=%RU32 aFilename=%p\n", this, "Machine::queryLogFilename", aIdx, aFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilename);


        
        BSTROutConverter TmpFilename(aFilename);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYLOGFILENAME_ENTER(this, aIdx);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryLogFilename(aIdx,
                                   TmpFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYLOGFILENAME_RETURN(this, hrc, 0 /*normal*/, aIdx, TmpFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYLOGFILENAME_RETURN(this, hrc, 1 /*hrc exception*/, aIdx, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_QUERYLOGFILENAME_RETURN(this, hrc, 9 /*unhandled exception*/, aIdx, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFilename=%ls hrc=%Rhrc\n", this, "Machine::queryLogFilename", !RT_VALID_PTR(aFilename) ? 0 : *aFilename, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ReadLog(ULONG aIdx,
                                  LONG64 aOffset,
                                  LONG64 aSize,
                                  ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aIdx=%RU32 aOffset=%RI64 aSize=%RI64 aData=%p\n", this, "Machine::readLog", aIdx, aOffset, aSize, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READLOG_ENTER(this, aIdx, aOffset, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readLog(aIdx,
                          aOffset,
                          aSize,
                          TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READLOG_RETURN(this, hrc, 0 /*normal*/, aIdx, aOffset, aSize, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READLOG_RETURN(this, hrc, 1 /*hrc exception*/, aIdx, aOffset, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_READLOG_RETURN(this, hrc, 9 /*unhandled exception*/, aIdx, aOffset, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "Machine::readLog", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::CloneTo(IMachine *aTarget,
                                  CloneMode_T aMode,
                                  ComSafeArrayIn(CloneOptions_T, aOptions),
                                  IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aMode=%RU32 aOptions=%zu aProgress=%p\n", this, "Machine::cloneTo", aTarget, aMode, aOptions, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<IMachine> TmpTarget(aTarget);
        
        ArrayInConverter<CloneOptions_T> TmpOptions(ComSafeArrayInArg(aOptions));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLONETO_ENTER(this, (void *)TmpTarget.ptr(), aMode, (uint32_t)TmpOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cloneTo(TmpTarget.ptr(),
                          aMode,
                          TmpOptions.array(),
                          TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLONETO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), aMode, (uint32_t)TmpOptions.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLONETO_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLONETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::cloneTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::MoveTo(IN_BSTR aFolder,
                                 IN_BSTR aType,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFolder=%ls aType=%ls aProgress=%p\n", this, "Machine::moveTo", aFolder, aType, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFolder(aFolder);
        BSTRInConverter TmpType(aType);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOVETO_ENTER(this, TmpFolder.str().c_str(), TmpType.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = moveTo(TmpFolder.str(),
                         TmpType.str(),
                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOVETO_RETURN(this, hrc, 0 /*normal*/, TmpFolder.str().c_str(), TmpType.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOVETO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_MOVETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::moveTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::SaveState(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Machine::saveState", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESTATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = saveState(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESTATE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESTATE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_SAVESTATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::saveState", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AdoptSavedState(IN_BSTR aSavedStateFile)
{
    LogRelFlow(("{%p} %s: enter aSavedStateFile=%ls\n", this, "Machine::adoptSavedState", aSavedStateFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSavedStateFile(aSavedStateFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADOPTSAVEDSTATE_ENTER(this, TmpSavedStateFile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = adoptSavedState(TmpSavedStateFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADOPTSAVEDSTATE_RETURN(this, hrc, 0 /*normal*/, TmpSavedStateFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADOPTSAVEDSTATE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADOPTSAVEDSTATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::adoptSavedState", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DiscardSavedState(BOOL aFRemoveFile)
{
    LogRelFlow(("{%p} %s: enter aFRemoveFile=%RTbool\n", this, "Machine::discardSavedState", aFRemoveFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSAVEDSTATE_ENTER(this, aFRemoveFile != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = discardSavedState(aFRemoveFile != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSAVEDSTATE_RETURN(this, hrc, 0 /*normal*/, aFRemoveFile != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSAVEDSTATE_RETURN(this, hrc, 1 /*hrc exception*/, aFRemoveFile != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DISCARDSAVEDSTATE_RETURN(this, hrc, 9 /*unhandled exception*/, aFRemoveFile != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::discardSavedState", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::TakeSnapshot(IN_BSTR aName,
                                       IN_BSTR aDescription,
                                       BOOL aPause,
                                       BSTR *aId,
                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDescription=%ls aPause=%RTbool aId=%p aProgress=%p\n", this, "Machine::takeSnapshot", aName, aDescription, aPause, aId, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpDescription(aDescription);
        
        UuidOutConverter TmpId(aId);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TAKESNAPSHOT_ENTER(this, TmpName.str().c_str(), TmpDescription.str().c_str(), aPause != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = takeSnapshot(TmpName.str(),
                               TmpDescription.str(),
                               aPause != FALSE,
                               TmpId.uuid(),
                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TAKESNAPSHOT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpDescription.str().c_str(), aPause != FALSE, TmpId.uuid().toStringCurly().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TAKESNAPSHOT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aPause != FALSE, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_TAKESNAPSHOT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aPause != FALSE, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls aProgress=%p hrc=%Rhrc\n", this, "Machine::takeSnapshot", !RT_VALID_PTR(aId) ? 0 : *aId, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DeleteSnapshot(IN_BSTR aId,
                                         IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aProgress=%p\n", this, "Machine::deleteSnapshot", aId, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOT_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteSnapshot(TmpId.uuid(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOT_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::deleteSnapshot", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DeleteSnapshotAndAllChildren(IN_BSTR aId,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aProgress=%p\n", this, "Machine::deleteSnapshotAndAllChildren", aId, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTANDALLCHILDREN_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteSnapshotAndAllChildren(TmpId.uuid(),
                                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTANDALLCHILDREN_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTANDALLCHILDREN_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTANDALLCHILDREN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::deleteSnapshotAndAllChildren", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DeleteSnapshotRange(IN_BSTR aStartId,
                                              IN_BSTR aEndId,
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aStartId=%ls aEndId=%ls aProgress=%p\n", this, "Machine::deleteSnapshotRange", aStartId, aEndId, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        UuidInConverter TmpStartId(aStartId);
        UuidInConverter TmpEndId(aEndId);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTRANGE_ENTER(this, TmpStartId.uuid().toStringCurly().c_str(), TmpEndId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteSnapshotRange(TmpStartId.uuid(),
                                      TmpEndId.uuid(),
                                      TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTRANGE_RETURN(this, hrc, 0 /*normal*/, TmpStartId.uuid().toStringCurly().c_str(), TmpEndId.uuid().toStringCurly().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTRANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DELETESNAPSHOTRANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::deleteSnapshotRange", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RestoreSnapshot(ISnapshot *aSnapshot,
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSnapshot=%p aProgress=%p\n", this, "Machine::restoreSnapshot", aSnapshot, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<ISnapshot> TmpSnapshot(aSnapshot);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RESTORESNAPSHOT_ENTER(this, (void *)TmpSnapshot.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = restoreSnapshot(TmpSnapshot.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RESTORESNAPSHOT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSnapshot.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RESTORESNAPSHOT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RESTORESNAPSHOT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::restoreSnapshot", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ApplyDefaults(IN_BSTR aFlags)
{
    LogRelFlow(("{%p} %s: enter aFlags=%ls\n", this, "Machine::applyDefaults", aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpFlags(aFlags);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_APPLYDEFAULTS_ENTER(this, TmpFlags.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = applyDefaults(TmpFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_APPLYDEFAULTS_RETURN(this, hrc, 0 /*normal*/, TmpFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_APPLYDEFAULTS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_APPLYDEFAULTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::applyDefaults", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ChangeEncryption(IN_BSTR aCurrentPassword,
                                           IN_BSTR aCipher,
                                           IN_BSTR aNewPassword,
                                           IN_BSTR aNewPasswordId,
                                           BOOL aForce,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aCurrentPassword=%ls aCipher=%ls aNewPassword=%ls aNewPasswordId=%ls aForce=%RTbool aProgress=%p\n", this, "Machine::changeEncryption", aCurrentPassword, aCipher, aNewPassword, aNewPasswordId, aForce, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpCurrentPassword(aCurrentPassword);
        BSTRInConverter TmpCipher(aCipher);
        BSTRInConverter TmpNewPassword(aNewPassword);
        BSTRInConverter TmpNewPasswordId(aNewPasswordId);
        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHANGEENCRYPTION_ENTER(this, TmpCurrentPassword.str().c_str(), TmpCipher.str().c_str(), TmpNewPassword.str().c_str(), TmpNewPasswordId.str().c_str(), aForce != FALSE);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = changeEncryption(TmpCurrentPassword.str(),
                                   TmpCipher.str(),
                                   TmpNewPassword.str(),
                                   TmpNewPasswordId.str(),
                                   aForce != FALSE,
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHANGEENCRYPTION_RETURN(this, hrc, 0 /*normal*/, TmpCurrentPassword.str().c_str(), TmpCipher.str().c_str(), TmpNewPassword.str().c_str(), TmpNewPasswordId.str().c_str(), aForce != FALSE, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHANGEENCRYPTION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, aForce != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHANGEENCRYPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, aForce != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::changeEncryption", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::GetEncryptionSettings(BSTR *aCipher,
                                                BSTR *aPasswordId)
{
    LogRelFlow(("{%p} %s: enter aCipher=%p aPasswordId=%p\n", this, "Machine::getEncryptionSettings", aCipher, aPasswordId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCipher);
        CheckComArgOutPointerValidThrow(aPasswordId);


        BSTROutConverter TmpCipher(aCipher);
        BSTROutConverter TmpPasswordId(aPasswordId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETENCRYPTIONSETTINGS_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEncryptionSettings(TmpCipher.str(),
                                        TmpPasswordId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETENCRYPTIONSETTINGS_RETURN(this, hrc, 0 /*normal*/, TmpCipher.str().c_str(), TmpPasswordId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETENCRYPTIONSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_GETENCRYPTIONSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCipher=%ls *aPasswordId=%ls hrc=%Rhrc\n", this, "Machine::getEncryptionSettings", !RT_VALID_PTR(aCipher) ? 0 : *aCipher, !RT_VALID_PTR(aPasswordId) ? 0 : *aPasswordId, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::CheckEncryptionPassword(IN_BSTR aPassword)
{
    LogRelFlow(("{%p} %s: enter aPassword=%ls\n", this, "Machine::checkEncryptionPassword", aPassword));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPassword(aPassword);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHECKENCRYPTIONPASSWORD_ENTER(this, TmpPassword.str().c_str());
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkEncryptionPassword(TmpPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::checkEncryptionPassword", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AddEncryptionPassword(IN_BSTR aId,
                                                IN_BSTR aPassword)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aPassword=%ls\n", this, "Machine::addEncryptionPassword", aId, aPassword));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpId(aId);
        BSTRInConverter TmpPassword(aPassword);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str(), TmpPassword.str().c_str());
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addEncryptionPassword(TmpId.str(),
                                        TmpPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str(), TmpPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::addEncryptionPassword", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AddEncryptionPasswords(ComSafeArrayIn(IN_BSTR, aIds),
                                                 ComSafeArrayIn(IN_BSTR, aPasswords))
{
    LogRelFlow(("{%p} %s: enter aIds=%zu aPasswords=%zu\n", this, "Machine::addEncryptionPasswords", aIds, aPasswords));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpIds(ComSafeArrayInArg(aIds));
        ArrayBSTRInConverter TmpPasswords(ComSafeArrayInArg(aPasswords));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORDS_ENTER(this, (uint32_t)TmpIds.array().size(), NULL /*for now*/, (uint32_t)TmpPasswords.array().size(), NULL /*for now*/);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addEncryptionPasswords(TmpIds.array(),
                                         TmpPasswords.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpIds.array().size(), NULL /*for now*/, (uint32_t)TmpPasswords.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::addEncryptionPasswords", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RemoveEncryptionPassword(IN_BSTR aId)
{
    LogRelFlow(("{%p} %s: enter aId=%ls\n", this, "Machine::removeEncryptionPassword", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpId(aId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str());
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeEncryptionPassword(autoCaller,
                                       TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::removeEncryptionPassword", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ClearAllEncryptionPasswords()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::clearAllEncryptionPasswords"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLEARALLENCRYPTIONPASSWORDS_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = clearAllEncryptionPasswords(autoCaller);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::clearAllEncryptionPasswords", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod1IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod2IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod3IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod4IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod5IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod6IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod7IMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineWrap::InternalAndReservedMethod8IMachine()
{
    return E_NOTIMPL;
}

//
// IInternalMachineControl methods
//

STDMETHODIMP MachineWrap::UpdateState(MachineState_T aState)
{
    LogRelFlow(("{%p} %s: enter aState=%RU32\n", this, "Machine::updateState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UPDATESTATE_ENTER(this, aState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = updateState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UPDATESTATE_RETURN(this, hrc, 0 /*normal*/, aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UPDATESTATE_RETURN(this, hrc, 1 /*hrc exception*/, aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UPDATESTATE_RETURN(this, hrc, 9 /*unhandled exception*/, aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::updateState", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::BeginPowerUp(IProgress *aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Machine::beginPowerUp", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERUP_ENTER(this, (void *)TmpProgress.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = beginPowerUp(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERUP_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::beginPowerUp", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::EndPowerUp(LONG aResult)
{
    LogRelFlow(("{%p} %s: enter aResult=%RI32\n", this, "Machine::endPowerUp", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERUP_ENTER(this, aResult);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = endPowerUp(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERUP_RETURN(this, hrc, 0 /*normal*/, aResult);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERUP_RETURN(this, hrc, 1 /*hrc exception*/, aResult);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERUP_RETURN(this, hrc, 9 /*unhandled exception*/, aResult);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::endPowerUp", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::BeginPoweringDown(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Machine::beginPoweringDown", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERINGDOWN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = beginPoweringDown(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERINGDOWN_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERINGDOWN_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_BEGINPOWERINGDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProgress=%p hrc=%Rhrc\n", this, "Machine::beginPoweringDown", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::EndPoweringDown(LONG aResult,
                                          IN_BSTR aErrMsg)
{
    LogRelFlow(("{%p} %s: enter aResult=%RI32 aErrMsg=%ls\n", this, "Machine::endPoweringDown", aResult, aErrMsg));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        BSTRInConverter TmpErrMsg(aErrMsg);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERINGDOWN_ENTER(this, aResult, TmpErrMsg.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = endPoweringDown(aResult,
                                  TmpErrMsg.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERINGDOWN_RETURN(this, hrc, 0 /*normal*/, aResult, TmpErrMsg.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERINGDOWN_RETURN(this, hrc, 1 /*hrc exception*/, aResult, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ENDPOWERINGDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, aResult, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::endPoweringDown", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::RunUSBDeviceFilters(IUSBDevice *aDevice,
                                              BOOL *aMatched,
                                              ULONG *aMaskedInterfaces)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p aMatched=%p aMaskedInterfaces=%p\n", this, "Machine::runUSBDeviceFilters", aDevice, aMatched, aMaskedInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMatched);
        CheckComArgOutPointerValidThrow(aMaskedInterfaces);


        ComTypeInConverter<IUSBDevice> TmpDevice(aDevice);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RUNUSBDEVICEFILTERS_ENTER(this, (void *)TmpDevice.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = runUSBDeviceFilters(TmpDevice.ptr(),
                                      aMatched,
                                      aMaskedInterfaces);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RUNUSBDEVICEFILTERS_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDevice.ptr(), *aMatched != FALSE, *aMaskedInterfaces);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RUNUSBDEVICEFILTERS_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aMatched != FALSE, *aMaskedInterfaces);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_RUNUSBDEVICEFILTERS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aMatched != FALSE, *aMaskedInterfaces);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMatched=%RTbool *aMaskedInterfaces=%RU32 hrc=%Rhrc\n", this, "Machine::runUSBDeviceFilters", !RT_VALID_PTR(aMatched) ? 0 : *aMatched, !RT_VALID_PTR(aMaskedInterfaces) ? 0 : *aMaskedInterfaces, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::CaptureUSBDevice(IN_BSTR aId,
                                           IN_BSTR aCaptureFilename)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aCaptureFilename=%ls\n", this, "Machine::captureUSBDevice", aId, aCaptureFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpId(aId);
        BSTRInConverter TmpCaptureFilename(aCaptureFilename);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CAPTUREUSBDEVICE_ENTER(this, TmpId.uuid().toStringCurly().c_str(), TmpCaptureFilename.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = captureUSBDevice(TmpId.uuid(),
                                   TmpCaptureFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CAPTUREUSBDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), TmpCaptureFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CAPTUREUSBDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_CAPTUREUSBDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::captureUSBDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DetachUSBDevice(IN_BSTR aId,
                                          BOOL aDone)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aDone=%RTbool\n", this, "Machine::detachUSBDevice", aId, aDone));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpId(aId);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHUSBDEVICE_ENTER(this, TmpId.uuid().toStringCurly().c_str(), aDone != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachUSBDevice(TmpId.uuid(),
                                  aDone != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHUSBDEVICE_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), aDone != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHUSBDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aDone != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHUSBDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aDone != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::detachUSBDevice", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AutoCaptureUSBDevices()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::autoCaptureUSBDevices"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTOCAPTUREUSBDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = autoCaptureUSBDevices();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTOCAPTUREUSBDEVICES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTOCAPTUREUSBDEVICES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTOCAPTUREUSBDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::autoCaptureUSBDevices", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::DetachAllUSBDevices(BOOL aDone)
{
    LogRelFlow(("{%p} %s: enter aDone=%RTbool\n", this, "Machine::detachAllUSBDevices", aDone));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHALLUSBDEVICES_ENTER(this, aDone != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachAllUSBDevices(aDone != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHALLUSBDEVICES_RETURN(this, hrc, 0 /*normal*/, aDone != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHALLUSBDEVICES_RETURN(this, hrc, 1 /*hrc exception*/, aDone != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_DETACHALLUSBDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/, aDone != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::detachAllUSBDevices", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::OnSessionEnd(ISession *aSession,
                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSession=%p aProgress=%p\n", this, "Machine::onSessionEnd", aSession, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<ISession> TmpSession(aSession);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ONSESSIONEND_ENTER(this, (void *)TmpSession.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onSessionEnd(TmpSession.ptr(),
                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ONSESSIONEND_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSession.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ONSESSIONEND_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_ONSESSIONEND_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Machine::onSessionEnd", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::FinishOnlineMergeMedium()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::finishOnlineMergeMedium"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINISHONLINEMERGEMEDIUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = finishOnlineMergeMedium();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINISHONLINEMERGEMEDIUM_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINISHONLINEMERGEMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_FINISHONLINEMERGEMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::finishOnlineMergeMedium", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::PullGuestProperties(ComSafeArrayOut(BSTR, aNames),
                                              ComSafeArrayOut(BSTR, aValues),
                                              ComSafeArrayOut(LONG64, aTimestamps),
                                              ComSafeArrayOut(BSTR, aFlags))
{
    LogRelFlow(("{%p} %s: enter aNames=%p aValues=%p aTimestamps=%p aFlags=%p\n", this, "Machine::pullGuestProperties", aNames, aValues, aTimestamps, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNames);
        CheckComArgOutPointerValidThrow(aValues);
        CheckComArgOutPointerValidThrow(aTimestamps);
        CheckComArgOutPointerValidThrow(aFlags);


        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));
        ArrayOutConverter<LONG64> TmpTimestamps(ComSafeArrayOutArg(aTimestamps));
        ArrayBSTROutConverter TmpFlags(ComSafeArrayOutArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PULLGUESTPROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = pullGuestProperties(TmpNames.array(),
                                      TmpValues.array(),
                                      TmpTimestamps.array(),
                                      TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PULLGUESTPROPERTIES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/, (uint32_t)TmpTimestamps.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PULLGUESTPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PULLGUESTPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aValues=%zu *aTimestamps=%zu *aFlags=%zu hrc=%Rhrc\n", this, "Machine::pullGuestProperties", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), !RT_VALID_PTR(aTimestamps) ? 0 : ComSafeArraySize(*aTimestamps), !RT_VALID_PTR(aFlags) ? 0 : ComSafeArraySize(*aFlags), hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::PushGuestProperty(IN_BSTR aName,
                                            IN_BSTR aValue,
                                            LONG64 aTimestamp,
                                            IN_BSTR aFlags,
                                            BOOL aFWasDeleted)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%ls aTimestamp=%RI64 aFlags=%ls aFWasDeleted=%RTbool\n", this, "Machine::pushGuestProperty", aName, aValue, aTimestamp, aFlags, aFWasDeleted));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);
        
        BSTRInConverter TmpFlags(aFlags);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PUSHGUESTPROPERTY_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str(), aTimestamp, TmpFlags.str().c_str(), aFWasDeleted != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = pushGuestProperty(TmpName.str(),
                                    TmpValue.str(),
                                    aTimestamp,
                                    TmpFlags.str(),
                                    aFWasDeleted != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PUSHGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str(), aTimestamp, TmpFlags.str().c_str(), aFWasDeleted != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PUSHGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimestamp, 0, aFWasDeleted != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_PUSHGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimestamp, 0, aFWasDeleted != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::pushGuestProperty", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::LockMedia()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::lockMedia"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMEDIA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = lockMedia();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMEDIA_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMEDIA_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_LOCKMEDIA_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::lockMedia", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::UnlockMedia()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Machine::unlockMedia"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNLOCKMEDIA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unlockMedia();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNLOCKMEDIA_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNLOCKMEDIA_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_UNLOCKMEDIA_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::unlockMedia", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::EjectMedium(IMediumAttachment *aAttachment,
                                      IMediumAttachment **aNewAttachment)
{
    LogRelFlow(("{%p} %s: enter aAttachment=%p aNewAttachment=%p\n", this, "Machine::ejectMedium", aAttachment, aNewAttachment));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNewAttachment);


        ComTypeInConverter<IMediumAttachment> TmpAttachment(aAttachment);
        ComTypeOutConverter<IMediumAttachment> TmpNewAttachment(aNewAttachment);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EJECTMEDIUM_ENTER(this, (void *)TmpAttachment.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = ejectMedium(TmpAttachment.ptr(),
                              TmpNewAttachment.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EJECTMEDIUM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpAttachment.ptr(), (void *)TmpNewAttachment.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EJECTMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_EJECTMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNewAttachment=%p hrc=%Rhrc\n", this, "Machine::ejectMedium", !RT_VALID_PTR(aNewAttachment) ? 0 : *aNewAttachment, hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::ReportVmStatistics(ULONG aValidStats,
                                             ULONG aCpuUser,
                                             ULONG aCpuKernel,
                                             ULONG aCpuIdle,
                                             ULONG aMemTotal,
                                             ULONG aMemFree,
                                             ULONG aMemBalloon,
                                             ULONG aMemShared,
                                             ULONG aMemCache,
                                             ULONG aPagedTotal,
                                             ULONG aMemAllocTotal,
                                             ULONG aMemFreeTotal,
                                             ULONG aMemBalloonTotal,
                                             ULONG aMemSharedTotal,
                                             ULONG aVmNetRx,
                                             ULONG aVmNetTx)
{
    LogRelFlow(("{%p} %s: enter aValidStats=%RU32 aCpuUser=%RU32 aCpuKernel=%RU32 aCpuIdle=%RU32 aMemTotal=%RU32 aMemFree=%RU32 aMemBalloon=%RU32 aMemShared=%RU32 aMemCache=%RU32 aPagedTotal=%RU32 aMemAllocTotal=%RU32 aMemFreeTotal=%RU32 aMemBalloonTotal=%RU32 aMemSharedTotal=%RU32 aVmNetRx=%RU32 aVmNetTx=%RU32\n", this, "Machine::reportVmStatistics", aValidStats, aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal, aVmNetRx, aVmNetTx));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REPORTVMSTATISTICS_ENTER(this, aValidStats, aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal, aVmNetRx, aVmNetTx);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reportVmStatistics(aValidStats,
                                     aCpuUser,
                                     aCpuKernel,
                                     aCpuIdle,
                                     aMemTotal,
                                     aMemFree,
                                     aMemBalloon,
                                     aMemShared,
                                     aMemCache,
                                     aPagedTotal,
                                     aMemAllocTotal,
                                     aMemFreeTotal,
                                     aMemBalloonTotal,
                                     aMemSharedTotal,
                                     aVmNetRx,
                                     aVmNetTx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REPORTVMSTATISTICS_RETURN(this, hrc, 0 /*normal*/, aValidStats, aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal, aVmNetRx, aVmNetTx);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REPORTVMSTATISTICS_RETURN(this, hrc, 1 /*hrc exception*/, aValidStats, aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal, aVmNetRx, aVmNetTx);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_REPORTVMSTATISTICS_RETURN(this, hrc, 9 /*unhandled exception*/, aValidStats, aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal, aVmNetRx, aVmNetTx);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Machine::reportVmStatistics", hrc));
    return hrc;
}

STDMETHODIMP MachineWrap::AuthenticateExternal(ComSafeArrayIn(IN_BSTR, aAuthParams),
                                               BSTR *aResult)
{
    LogRelFlow(("{%p} %s: enter aAuthParams=%zu aResult=%p\n", this, "Machine::authenticateExternal", aAuthParams, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayBSTRInConverter TmpAuthParams(ComSafeArrayInArg(aAuthParams));
        BSTROutConverter TmpResult(aResult);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTHENTICATEEXTERNAL_ENTER(this, (uint32_t)TmpAuthParams.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = authenticateExternal(TmpAuthParams.array(),
                                       TmpResult.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTHENTICATEEXTERNAL_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpAuthParams.array().size(), NULL /*for now*/, TmpResult.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTHENTICATEEXTERNAL_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINE_AUTHENTICATEEXTERNAL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aResult=%ls hrc=%Rhrc\n", this, "Machine::authenticateExternal", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MachineWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MachineWrap, IMachine)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MachineWrap.cpp"


// ##### BEGINFILE "VRDEServerInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVRDEServerInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VRDESERVERINFO

#include "VRDEServerInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VRDEServerInfoWrap)

//
// IVRDEServerInfo properties
//

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(Active)(BOOL *aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%p\n", this, "VRDEServerInfo::getActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aActive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ACTIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getActive(aActive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,*aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aActive=%RTbool hrc=%Rhrc\n", this, "VRDEServerInfo::getActive", !RT_VALID_PTR(aActive) ? 0 : *aActive, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(Port)(LONG *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "VRDEServerInfo::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(aPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_PORT_RETURN(this, hrc, 0 /*normal*/,*aPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,*aPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%RI32 hrc=%Rhrc\n", this, "VRDEServerInfo::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(NumberOfClients)(ULONG *aNumberOfClients)
{
    LogRelFlow(("{%p} %s: enter aNumberOfClients=%p\n", this, "VRDEServerInfo::getNumberOfClients", aNumberOfClients));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNumberOfClients);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_NUMBEROFCLIENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNumberOfClients(aNumberOfClients);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_NUMBEROFCLIENTS_RETURN(this, hrc, 0 /*normal*/,*aNumberOfClients);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_NUMBEROFCLIENTS_RETURN(this, hrc, 1 /*hrc exception*/,*aNumberOfClients);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_NUMBEROFCLIENTS_RETURN(this, hrc, 9 /*unhandled exception*/,*aNumberOfClients);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNumberOfClients=%RU32 hrc=%Rhrc\n", this, "VRDEServerInfo::getNumberOfClients", !RT_VALID_PTR(aNumberOfClients) ? 0 : *aNumberOfClients, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(BeginTime)(LONG64 *aBeginTime)
{
    LogRelFlow(("{%p} %s: enter aBeginTime=%p\n", this, "VRDEServerInfo::getBeginTime", aBeginTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBeginTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BEGINTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBeginTime(aBeginTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BEGINTIME_RETURN(this, hrc, 0 /*normal*/,*aBeginTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BEGINTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aBeginTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BEGINTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aBeginTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBeginTime=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getBeginTime", !RT_VALID_PTR(aBeginTime) ? 0 : *aBeginTime, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(EndTime)(LONG64 *aEndTime)
{
    LogRelFlow(("{%p} %s: enter aEndTime=%p\n", this, "VRDEServerInfo::getEndTime", aEndTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEndTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENDTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEndTime(aEndTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENDTIME_RETURN(this, hrc, 0 /*normal*/,*aEndTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENDTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aEndTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENDTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aEndTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEndTime=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getEndTime", !RT_VALID_PTR(aEndTime) ? 0 : *aEndTime, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(BytesSent)(LONG64 *aBytesSent)
{
    LogRelFlow(("{%p} %s: enter aBytesSent=%p\n", this, "VRDEServerInfo::getBytesSent", aBytesSent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesSent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesSent(aBytesSent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENT_RETURN(this, hrc, 0 /*normal*/,*aBytesSent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENT_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesSent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesSent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesSent=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getBytesSent", !RT_VALID_PTR(aBytesSent) ? 0 : *aBytesSent, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(BytesSentTotal)(LONG64 *aBytesSentTotal)
{
    LogRelFlow(("{%p} %s: enter aBytesSentTotal=%p\n", this, "VRDEServerInfo::getBytesSentTotal", aBytesSentTotal));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesSentTotal);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENTTOTAL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesSentTotal(aBytesSentTotal);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENTTOTAL_RETURN(this, hrc, 0 /*normal*/,*aBytesSentTotal);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENTTOTAL_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesSentTotal);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESSENTTOTAL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesSentTotal);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesSentTotal=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getBytesSentTotal", !RT_VALID_PTR(aBytesSentTotal) ? 0 : *aBytesSentTotal, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(BytesReceived)(LONG64 *aBytesReceived)
{
    LogRelFlow(("{%p} %s: enter aBytesReceived=%p\n", this, "VRDEServerInfo::getBytesReceived", aBytesReceived));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesReceived);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesReceived(aBytesReceived);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVED_RETURN(this, hrc, 0 /*normal*/,*aBytesReceived);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVED_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesReceived);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVED_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesReceived);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesReceived=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getBytesReceived", !RT_VALID_PTR(aBytesReceived) ? 0 : *aBytesReceived, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(BytesReceivedTotal)(LONG64 *aBytesReceivedTotal)
{
    LogRelFlow(("{%p} %s: enter aBytesReceivedTotal=%p\n", this, "VRDEServerInfo::getBytesReceivedTotal", aBytesReceivedTotal));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesReceivedTotal);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVEDTOTAL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesReceivedTotal(aBytesReceivedTotal);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVEDTOTAL_RETURN(this, hrc, 0 /*normal*/,*aBytesReceivedTotal);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVEDTOTAL_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesReceivedTotal);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_BYTESRECEIVEDTOTAL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesReceivedTotal);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesReceivedTotal=%RI64 hrc=%Rhrc\n", this, "VRDEServerInfo::getBytesReceivedTotal", !RT_VALID_PTR(aBytesReceivedTotal) ? 0 : *aBytesReceivedTotal, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(User)(BSTR *aUser)
{
    LogRelFlow(("{%p} %s: enter aUser=%p\n", this, "VRDEServerInfo::getUser", aUser));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUser);
        BSTROutConverter TmpUser(aUser);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_USER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUser(TmpUser.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_USER_RETURN(this, hrc, 0 /*normal*/,TmpUser.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_USER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_USER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUser=%ls hrc=%Rhrc\n", this, "VRDEServerInfo::getUser", !RT_VALID_PTR(aUser) ? 0 : *aUser, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(Domain)(BSTR *aDomain)
{
    LogRelFlow(("{%p} %s: enter aDomain=%p\n", this, "VRDEServerInfo::getDomain", aDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDomain);
        BSTROutConverter TmpDomain(aDomain);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_DOMAIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDomain(TmpDomain.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_DOMAIN_RETURN(this, hrc, 0 /*normal*/,TmpDomain.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_DOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_DOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDomain=%ls hrc=%Rhrc\n", this, "VRDEServerInfo::getDomain", !RT_VALID_PTR(aDomain) ? 0 : *aDomain, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(ClientName)(BSTR *aClientName)
{
    LogRelFlow(("{%p} %s: enter aClientName=%p\n", this, "VRDEServerInfo::getClientName", aClientName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClientName);
        BSTROutConverter TmpClientName(aClientName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClientName(TmpClientName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTNAME_RETURN(this, hrc, 0 /*normal*/,TmpClientName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClientName=%ls hrc=%Rhrc\n", this, "VRDEServerInfo::getClientName", !RT_VALID_PTR(aClientName) ? 0 : *aClientName, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(ClientIP)(BSTR *aClientIP)
{
    LogRelFlow(("{%p} %s: enter aClientIP=%p\n", this, "VRDEServerInfo::getClientIP", aClientIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClientIP);
        BSTROutConverter TmpClientIP(aClientIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClientIP(TmpClientIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTIP_RETURN(this, hrc, 0 /*normal*/,TmpClientIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClientIP=%ls hrc=%Rhrc\n", this, "VRDEServerInfo::getClientIP", !RT_VALID_PTR(aClientIP) ? 0 : *aClientIP, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(ClientVersion)(ULONG *aClientVersion)
{
    LogRelFlow(("{%p} %s: enter aClientVersion=%p\n", this, "VRDEServerInfo::getClientVersion", aClientVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClientVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClientVersion(aClientVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTVERSION_RETURN(this, hrc, 0 /*normal*/,*aClientVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTVERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aClientVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_CLIENTVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aClientVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClientVersion=%RU32 hrc=%Rhrc\n", this, "VRDEServerInfo::getClientVersion", !RT_VALID_PTR(aClientVersion) ? 0 : *aClientVersion, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(EncryptionStyle)(ULONG *aEncryptionStyle)
{
    LogRelFlow(("{%p} %s: enter aEncryptionStyle=%p\n", this, "VRDEServerInfo::getEncryptionStyle", aEncryptionStyle));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEncryptionStyle);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENCRYPTIONSTYLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEncryptionStyle(aEncryptionStyle);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENCRYPTIONSTYLE_RETURN(this, hrc, 0 /*normal*/,*aEncryptionStyle);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENCRYPTIONSTYLE_RETURN(this, hrc, 1 /*hrc exception*/,*aEncryptionStyle);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVERINFO_GET_ENCRYPTIONSTYLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aEncryptionStyle);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEncryptionStyle=%RU32 hrc=%Rhrc\n", this, "VRDEServerInfo::getEncryptionStyle", !RT_VALID_PTR(aEncryptionStyle) ? 0 : *aEncryptionStyle, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute1IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute2IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute3IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute4IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute5IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute6IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute7IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerInfoWrap::COMGETTER(InternalAndReservedAttribute8IVRDEServerInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVRDEServerInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VRDEServerInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VRDEServerInfoWrap, IVRDEServerInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VRDEServerInfoWrap.cpp"


// ##### BEGINFILE "HostVideoInputDeviceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostVideoInputDevice.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTVIDEOINPUTDEVICE

#include "HostVideoInputDeviceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostVideoInputDeviceWrap)

//
// IHostVideoInputDevice properties
//

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostVideoInputDevice::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "HostVideoInputDevice::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "HostVideoInputDevice::getPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPath);
        BSTROutConverter TmpPath(aPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_PATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPath=%ls hrc=%Rhrc\n", this, "HostVideoInputDevice::getPath", !RT_VALID_PTR(aPath) ? 0 : *aPath, hrc));
    return hrc;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(Alias)(BSTR *aAlias)
{
    LogRelFlow(("{%p} %s: enter aAlias=%p\n", this, "HostVideoInputDevice::getAlias", aAlias));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAlias);
        BSTROutConverter TmpAlias(aAlias);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_ALIAS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAlias(TmpAlias.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_ALIAS_RETURN(this, hrc, 0 /*normal*/,TmpAlias.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_ALIAS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTVIDEOINPUTDEVICE_GET_ALIAS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAlias=%ls hrc=%Rhrc\n", this, "HostVideoInputDevice::getAlias", !RT_VALID_PTR(aAlias) ? 0 : *aAlias, hrc));
    return hrc;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(InternalAndReservedAttribute1IHostVideoInputDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(InternalAndReservedAttribute2IHostVideoInputDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(InternalAndReservedAttribute3IHostVideoInputDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostVideoInputDeviceWrap::COMGETTER(InternalAndReservedAttribute4IHostVideoInputDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostVideoInputDevice methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostVideoInputDeviceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostVideoInputDeviceWrap, IHostVideoInputDevice)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostVideoInputDeviceWrap.cpp"


// ##### BEGINFILE "UpdateAgentWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUpdateAgent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_UPDATEAGENT

#include "UpdateAgentWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(UpdateAgentWrap)

//
// IUpdateAgent properties
//

STDMETHODIMP UpdateAgentWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "UpdateAgent::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "UpdateAgent::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "UpdateAgent::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "UpdateAgent::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(Order)(ULONG *aOrder)
{
    LogRelFlow(("{%p} %s: enter aOrder=%p\n", this, "UpdateAgent::getOrder", aOrder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOrder);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ORDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOrder(aOrder);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ORDER_RETURN(this, hrc, 0 /*normal*/,*aOrder);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ORDER_RETURN(this, hrc, 1 /*hrc exception*/,*aOrder);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ORDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aOrder);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOrder=%RU32 hrc=%Rhrc\n", this, "UpdateAgent::getOrder", !RT_VALID_PTR(aOrder) ? 0 : *aOrder, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(DependsOn)(ComSafeArrayOut(BSTR, aDependsOn))
{
    LogRelFlow(("{%p} %s: enter aDependsOn=%p\n", this, "UpdateAgent::getDependsOn", aDependsOn));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDependsOn);
        ArrayBSTROutConverter TmpDependsOn(ComSafeArrayOutArg(aDependsOn));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DEPENDSON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDependsOn(TmpDependsOn.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DEPENDSON_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDependsOn.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DEPENDSON_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DEPENDSON_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDependsOn=%zu hrc=%Rhrc\n", this, "UpdateAgent::getDependsOn", !RT_VALID_PTR(aDependsOn) ? 0 : ComSafeArraySize(*aDependsOn), hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "UpdateAgent::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "UpdateAgent::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(DownloadUrl)(BSTR *aDownloadUrl)
{
    LogRelFlow(("{%p} %s: enter aDownloadUrl=%p\n", this, "UpdateAgent::getDownloadUrl", aDownloadUrl));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDownloadUrl);
        BSTROutConverter TmpDownloadUrl(aDownloadUrl);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DOWNLOADURL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDownloadUrl(TmpDownloadUrl.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DOWNLOADURL_RETURN(this, hrc, 0 /*normal*/,TmpDownloadUrl.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DOWNLOADURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_DOWNLOADURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDownloadUrl=%ls hrc=%Rhrc\n", this, "UpdateAgent::getDownloadUrl", !RT_VALID_PTR(aDownloadUrl) ? 0 : *aDownloadUrl, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(WebUrl)(BSTR *aWebUrl)
{
    LogRelFlow(("{%p} %s: enter aWebUrl=%p\n", this, "UpdateAgent::getWebUrl", aWebUrl));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWebUrl);
        BSTROutConverter TmpWebUrl(aWebUrl);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_WEBURL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWebUrl(TmpWebUrl.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_WEBURL_RETURN(this, hrc, 0 /*normal*/,TmpWebUrl.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_WEBURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_WEBURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWebUrl=%ls hrc=%Rhrc\n", this, "UpdateAgent::getWebUrl", !RT_VALID_PTR(aWebUrl) ? 0 : *aWebUrl, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(ReleaseNotes)(BSTR *aReleaseNotes)
{
    LogRelFlow(("{%p} %s: enter aReleaseNotes=%p\n", this, "UpdateAgent::getReleaseNotes", aReleaseNotes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReleaseNotes);
        BSTROutConverter TmpReleaseNotes(aReleaseNotes);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_RELEASENOTES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReleaseNotes(TmpReleaseNotes.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_RELEASENOTES_RETURN(this, hrc, 0 /*normal*/,TmpReleaseNotes.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_RELEASENOTES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_RELEASENOTES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReleaseNotes=%ls hrc=%Rhrc\n", this, "UpdateAgent::getReleaseNotes", !RT_VALID_PTR(aReleaseNotes) ? 0 : *aReleaseNotes, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "UpdateAgent::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "UpdateAgent::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "UpdateAgent::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgent::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(Hidden)(BOOL *aHidden)
{
    LogRelFlow(("{%p} %s: enter aHidden=%p\n", this, "UpdateAgent::getHidden", aHidden));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHidden);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_HIDDEN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHidden(aHidden);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_HIDDEN_RETURN(this, hrc, 0 /*normal*/,*aHidden != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_HIDDEN_RETURN(this, hrc, 1 /*hrc exception*/,*aHidden != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_HIDDEN_RETURN(this, hrc, 9 /*unhandled exception*/,*aHidden != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHidden=%RTbool hrc=%Rhrc\n", this, "UpdateAgent::getHidden", !RT_VALID_PTR(aHidden) ? 0 : *aHidden, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(State)(UpdateState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "UpdateAgent::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "UpdateAgent::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(CheckFrequency)(ULONG *aCheckFrequency)
{
    LogRelFlow(("{%p} %s: enter aCheckFrequency=%p\n", this, "UpdateAgent::getCheckFrequency", aCheckFrequency));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCheckFrequency);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKFREQUENCY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCheckFrequency(aCheckFrequency);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKFREQUENCY_RETURN(this, hrc, 0 /*normal*/,*aCheckFrequency);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKFREQUENCY_RETURN(this, hrc, 1 /*hrc exception*/,*aCheckFrequency);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKFREQUENCY_RETURN(this, hrc, 9 /*unhandled exception*/,*aCheckFrequency);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCheckFrequency=%RU32 hrc=%Rhrc\n", this, "UpdateAgent::getCheckFrequency", !RT_VALID_PTR(aCheckFrequency) ? 0 : *aCheckFrequency, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMSETTER(CheckFrequency)(ULONG aCheckFrequency)
{
    LogRelFlow(("{%p} %s: enter aCheckFrequency=%RU32\n", this, "UpdateAgent::setCheckFrequency", aCheckFrequency));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHECKFREQUENCY_ENTER(this, aCheckFrequency);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCheckFrequency(aCheckFrequency);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHECKFREQUENCY_RETURN(this, hrc, 0 /*normal*/,aCheckFrequency);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHECKFREQUENCY_RETURN(this, hrc, 1 /*hrc exception*/,aCheckFrequency);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHECKFREQUENCY_RETURN(this, hrc, 9 /*unhandled exception*/,aCheckFrequency);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgent::setCheckFrequency", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(Channel)(UpdateChannel_T *aChannel)
{
    LogRelFlow(("{%p} %s: enter aChannel=%p\n", this, "UpdateAgent::getChannel", aChannel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChannel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHANNEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChannel(aChannel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHANNEL_RETURN(this, hrc, 0 /*normal*/,*aChannel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHANNEL_RETURN(this, hrc, 1 /*hrc exception*/,*aChannel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHANNEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aChannel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChannel=%RU32 hrc=%Rhrc\n", this, "UpdateAgent::getChannel", !RT_VALID_PTR(aChannel) ? 0 : *aChannel, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMSETTER(Channel)(UpdateChannel_T aChannel)
{
    LogRelFlow(("{%p} %s: enter aChannel=%RU32\n", this, "UpdateAgent::setChannel", aChannel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHANNEL_ENTER(this, aChannel);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setChannel(aChannel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHANNEL_RETURN(this, hrc, 0 /*normal*/,aChannel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHANNEL_RETURN(this, hrc, 1 /*hrc exception*/,aChannel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_CHANNEL_RETURN(this, hrc, 9 /*unhandled exception*/,aChannel);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgent::setChannel", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(RepositoryURL)(BSTR *aRepositoryURL)
{
    LogRelFlow(("{%p} %s: enter aRepositoryURL=%p\n", this, "UpdateAgent::getRepositoryURL", aRepositoryURL));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRepositoryURL);
        BSTROutConverter TmpRepositoryURL(aRepositoryURL);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_REPOSITORYURL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRepositoryURL(TmpRepositoryURL.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_REPOSITORYURL_RETURN(this, hrc, 0 /*normal*/,TmpRepositoryURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_REPOSITORYURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_REPOSITORYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRepositoryURL=%ls hrc=%Rhrc\n", this, "UpdateAgent::getRepositoryURL", !RT_VALID_PTR(aRepositoryURL) ? 0 : *aRepositoryURL, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMSETTER(RepositoryURL)(IN_BSTR aRepositoryURL)
{
    LogRelFlow(("{%p} %s: enter aRepositoryURL=%ls\n", this, "UpdateAgent::setRepositoryURL", aRepositoryURL));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpRepositoryURL(aRepositoryURL);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_REPOSITORYURL_ENTER(this, TmpRepositoryURL.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRepositoryURL(TmpRepositoryURL.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_REPOSITORYURL_RETURN(this, hrc, 0 /*normal*/,TmpRepositoryURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_REPOSITORYURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_SET_REPOSITORYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgent::setRepositoryURL", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(LastCheckDate)(BSTR *aLastCheckDate)
{
    LogRelFlow(("{%p} %s: enter aLastCheckDate=%p\n", this, "UpdateAgent::getLastCheckDate", aLastCheckDate));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastCheckDate);
        BSTROutConverter TmpLastCheckDate(aLastCheckDate);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_LASTCHECKDATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastCheckDate(TmpLastCheckDate.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_LASTCHECKDATE_RETURN(this, hrc, 0 /*normal*/,TmpLastCheckDate.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_LASTCHECKDATE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_LASTCHECKDATE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastCheckDate=%ls hrc=%Rhrc\n", this, "UpdateAgent::getLastCheckDate", !RT_VALID_PTR(aLastCheckDate) ? 0 : *aLastCheckDate, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(CheckCount)(ULONG *aCheckCount)
{
    LogRelFlow(("{%p} %s: enter aCheckCount=%p\n", this, "UpdateAgent::getCheckCount", aCheckCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCheckCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCheckCount(aCheckCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKCOUNT_RETURN(this, hrc, 0 /*normal*/,*aCheckCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCheckCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_CHECKCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCheckCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCheckCount=%RU32 hrc=%Rhrc\n", this, "UpdateAgent::getCheckCount", !RT_VALID_PTR(aCheckCount) ? 0 : *aCheckCount, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(IsCheckNeeded)(BOOL *aIsCheckNeeded)
{
    LogRelFlow(("{%p} %s: enter aIsCheckNeeded=%p\n", this, "UpdateAgent::getIsCheckNeeded", aIsCheckNeeded));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsCheckNeeded);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ISCHECKNEEDED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCheckNeeded(aIsCheckNeeded);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ISCHECKNEEDED_RETURN(this, hrc, 0 /*normal*/,*aIsCheckNeeded != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ISCHECKNEEDED_RETURN(this, hrc, 1 /*hrc exception*/,*aIsCheckNeeded != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_ISCHECKNEEDED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCheckNeeded != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsCheckNeeded=%RTbool hrc=%Rhrc\n", this, "UpdateAgent::getIsCheckNeeded", !RT_VALID_PTR(aIsCheckNeeded) ? 0 : *aIsCheckNeeded, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(SupportedChannels)(ComSafeArrayOut(UpdateChannel_T, aSupportedChannels))
{
    LogRelFlow(("{%p} %s: enter aSupportedChannels=%p\n", this, "UpdateAgent::getSupportedChannels", aSupportedChannels));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedChannels);
        ArrayOutConverter<UpdateChannel_T> TmpSupportedChannels(ComSafeArrayOutArg(aSupportedChannels));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_SUPPORTEDCHANNELS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedChannels(TmpSupportedChannels.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_SUPPORTEDCHANNELS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedChannels.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_SUPPORTEDCHANNELS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_GET_SUPPORTEDCHANNELS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedChannels=%zu hrc=%Rhrc\n", this, "UpdateAgent::getSupportedChannels", !RT_VALID_PTR(aSupportedChannels) ? 0 : ComSafeArraySize(*aSupportedChannels), hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(InternalAndReservedAttribute1IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(InternalAndReservedAttribute2IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(InternalAndReservedAttribute3IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UpdateAgentWrap::COMGETTER(InternalAndReservedAttribute4IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUpdateAgent methods
//

STDMETHODIMP UpdateAgentWrap::CheckFor(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "UpdateAgent::checkFor", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_CHECKFOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkFor(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_CHECKFOR_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_CHECKFOR_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_CHECKFOR_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "UpdateAgent::checkFor", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::Download(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "UpdateAgent::download", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_DOWNLOAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = download(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "UpdateAgent::download", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::Install(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "UpdateAgent::install", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_INSTALL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = install(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_INSTALL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_INSTALL_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_INSTALL_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "UpdateAgent::install", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::Rollback()
{
    LogRelFlow(("{%p} %s: enter\n", this, "UpdateAgent::rollback"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_ROLLBACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = rollback();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_ROLLBACK_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_ROLLBACK_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENT_ROLLBACK_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgent::rollback", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentWrap::InternalAndReservedMethod1IUpdateAgent()
{
    return E_NOTIMPL;
}

STDMETHODIMP UpdateAgentWrap::InternalAndReservedMethod2IUpdateAgent()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(UpdateAgentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(UpdateAgentWrap, IUpdateAgent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "UpdateAgentWrap.cpp"


// ##### BEGINFILE "HostDrivePartitionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostDrivePartition.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTDRIVEPARTITION

#include "HostDrivePartitionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostDrivePartitionWrap)

//
// IHostDrivePartition properties
//

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Number)(ULONG *aNumber)
{
    LogRelFlow(("{%p} %s: enter aNumber=%p\n", this, "HostDrivePartition::getNumber", aNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNumber);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNumber(aNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NUMBER_RETURN(this, hrc, 0 /*normal*/,*aNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNumber=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getNumber", !RT_VALID_PTR(aNumber) ? 0 : *aNumber, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Size)(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%p\n", this, "HostDrivePartition::getSize", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_SIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_SIZE_RETURN(this, hrc, 0 /*normal*/,*aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_SIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_SIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSize=%RI64 hrc=%Rhrc\n", this, "HostDrivePartition::getSize", !RT_VALID_PTR(aSize) ? 0 : *aSize, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Start)(LONG64 *aStart)
{
    LogRelFlow(("{%p} %s: enter aStart=%p\n", this, "HostDrivePartition::getStart", aStart));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStart);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_START_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStart(aStart);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_START_RETURN(this, hrc, 0 /*normal*/,*aStart);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_START_RETURN(this, hrc, 1 /*hrc exception*/,*aStart);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_START_RETURN(this, hrc, 9 /*unhandled exception*/,*aStart);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStart=%RI64 hrc=%Rhrc\n", this, "HostDrivePartition::getStart", !RT_VALID_PTR(aStart) ? 0 : *aStart, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Type)(PartitionType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "HostDrivePartition::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Active)(BOOL *aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%p\n", this, "HostDrivePartition::getActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aActive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ACTIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getActive(aActive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,*aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aActive=%RTbool hrc=%Rhrc\n", this, "HostDrivePartition::getActive", !RT_VALID_PTR(aActive) ? 0 : *aActive, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(TypeMBR)(ULONG *aTypeMBR)
{
    LogRelFlow(("{%p} %s: enter aTypeMBR=%p\n", this, "HostDrivePartition::getTypeMBR", aTypeMBR));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypeMBR);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEMBR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTypeMBR(aTypeMBR);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEMBR_RETURN(this, hrc, 0 /*normal*/,*aTypeMBR);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEMBR_RETURN(this, hrc, 1 /*hrc exception*/,*aTypeMBR);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEMBR_RETURN(this, hrc, 9 /*unhandled exception*/,*aTypeMBR);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypeMBR=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getTypeMBR", !RT_VALID_PTR(aTypeMBR) ? 0 : *aTypeMBR, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(StartCylinder)(ULONG *aStartCylinder)
{
    LogRelFlow(("{%p} %s: enter aStartCylinder=%p\n", this, "HostDrivePartition::getStartCylinder", aStartCylinder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStartCylinder);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTCYLINDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStartCylinder(aStartCylinder);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTCYLINDER_RETURN(this, hrc, 0 /*normal*/,*aStartCylinder);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTCYLINDER_RETURN(this, hrc, 1 /*hrc exception*/,*aStartCylinder);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTCYLINDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aStartCylinder);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStartCylinder=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getStartCylinder", !RT_VALID_PTR(aStartCylinder) ? 0 : *aStartCylinder, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(StartHead)(ULONG *aStartHead)
{
    LogRelFlow(("{%p} %s: enter aStartHead=%p\n", this, "HostDrivePartition::getStartHead", aStartHead));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStartHead);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTHEAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStartHead(aStartHead);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTHEAD_RETURN(this, hrc, 0 /*normal*/,*aStartHead);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTHEAD_RETURN(this, hrc, 1 /*hrc exception*/,*aStartHead);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTHEAD_RETURN(this, hrc, 9 /*unhandled exception*/,*aStartHead);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStartHead=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getStartHead", !RT_VALID_PTR(aStartHead) ? 0 : *aStartHead, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(StartSector)(ULONG *aStartSector)
{
    LogRelFlow(("{%p} %s: enter aStartSector=%p\n", this, "HostDrivePartition::getStartSector", aStartSector));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStartSector);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTSECTOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStartSector(aStartSector);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTSECTOR_RETURN(this, hrc, 0 /*normal*/,*aStartSector);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTSECTOR_RETURN(this, hrc, 1 /*hrc exception*/,*aStartSector);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_STARTSECTOR_RETURN(this, hrc, 9 /*unhandled exception*/,*aStartSector);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStartSector=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getStartSector", !RT_VALID_PTR(aStartSector) ? 0 : *aStartSector, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(EndCylinder)(ULONG *aEndCylinder)
{
    LogRelFlow(("{%p} %s: enter aEndCylinder=%p\n", this, "HostDrivePartition::getEndCylinder", aEndCylinder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEndCylinder);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDCYLINDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEndCylinder(aEndCylinder);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDCYLINDER_RETURN(this, hrc, 0 /*normal*/,*aEndCylinder);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDCYLINDER_RETURN(this, hrc, 1 /*hrc exception*/,*aEndCylinder);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDCYLINDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aEndCylinder);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEndCylinder=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getEndCylinder", !RT_VALID_PTR(aEndCylinder) ? 0 : *aEndCylinder, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(EndHead)(ULONG *aEndHead)
{
    LogRelFlow(("{%p} %s: enter aEndHead=%p\n", this, "HostDrivePartition::getEndHead", aEndHead));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEndHead);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDHEAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEndHead(aEndHead);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDHEAD_RETURN(this, hrc, 0 /*normal*/,*aEndHead);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDHEAD_RETURN(this, hrc, 1 /*hrc exception*/,*aEndHead);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDHEAD_RETURN(this, hrc, 9 /*unhandled exception*/,*aEndHead);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEndHead=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getEndHead", !RT_VALID_PTR(aEndHead) ? 0 : *aEndHead, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(EndSector)(ULONG *aEndSector)
{
    LogRelFlow(("{%p} %s: enter aEndSector=%p\n", this, "HostDrivePartition::getEndSector", aEndSector));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEndSector);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDSECTOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEndSector(aEndSector);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDSECTOR_RETURN(this, hrc, 0 /*normal*/,*aEndSector);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDSECTOR_RETURN(this, hrc, 1 /*hrc exception*/,*aEndSector);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_ENDSECTOR_RETURN(this, hrc, 9 /*unhandled exception*/,*aEndSector);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEndSector=%RU32 hrc=%Rhrc\n", this, "HostDrivePartition::getEndSector", !RT_VALID_PTR(aEndSector) ? 0 : *aEndSector, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(TypeUuid)(BSTR *aTypeUuid)
{
    LogRelFlow(("{%p} %s: enter aTypeUuid=%p\n", this, "HostDrivePartition::getTypeUuid", aTypeUuid));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypeUuid);
        UuidOutConverter TmpTypeUuid(aTypeUuid);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEUUID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTypeUuid(TmpTypeUuid.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEUUID_RETURN(this, hrc, 0 /*normal*/,TmpTypeUuid.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEUUID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_TYPEUUID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypeUuid=%ls hrc=%Rhrc\n", this, "HostDrivePartition::getTypeUuid", !RT_VALID_PTR(aTypeUuid) ? 0 : *aTypeUuid, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Uuid)(BSTR *aUuid)
{
    LogRelFlow(("{%p} %s: enter aUuid=%p\n", this, "HostDrivePartition::getUuid", aUuid));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUuid);
        UuidOutConverter TmpUuid(aUuid);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_UUID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUuid(TmpUuid.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_UUID_RETURN(this, hrc, 0 /*normal*/,TmpUuid.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_UUID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_UUID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUuid=%ls hrc=%Rhrc\n", this, "HostDrivePartition::getUuid", !RT_VALID_PTR(aUuid) ? 0 : *aUuid, hrc));
    return hrc;
}

STDMETHODIMP HostDrivePartitionWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostDrivePartition::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVEPARTITION_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "HostDrivePartition::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}


//
// IHostDrivePartition methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostDrivePartitionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostDrivePartitionWrap, IHostDrivePartition)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostDrivePartitionWrap.cpp"


// ##### BEGINFILE "HostX86Wrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostX86.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTX86

#include "HostX86Wrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostX86Wrap)

//
// IHostX86 properties
//

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute1IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute2IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute3IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute4IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute5IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute6IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute7IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute8IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute9IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute10IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute11IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::COMGETTER(InternalAndReservedAttribute12IHostX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostX86 methods
//

STDMETHODIMP HostX86Wrap::GetProcessorCPUIDLeaf(ULONG aCpuId,
                                                ULONG aLeaf,
                                                ULONG aSubLeaf,
                                                ULONG *aValEax,
                                                ULONG *aValEbx,
                                                ULONG *aValEcx,
                                                ULONG *aValEdx)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aLeaf=%RU32 aSubLeaf=%RU32 aValEax=%p aValEbx=%p aValEcx=%p aValEdx=%p\n", this, "HostX86::getProcessorCPUIDLeaf", aCpuId, aLeaf, aSubLeaf, aValEax, aValEbx, aValEcx, aValEdx));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValEax);
        CheckComArgOutPointerValidThrow(aValEbx);
        CheckComArgOutPointerValidThrow(aValEcx);
        CheckComArgOutPointerValidThrow(aValEdx);


        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTX86_GETPROCESSORCPUIDLEAF_ENTER(this, aCpuId, aLeaf, aSubLeaf);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessorCPUIDLeaf(aCpuId,
                                        aLeaf,
                                        aSubLeaf,
                                        aValEax,
                                        aValEbx,
                                        aValEcx,
                                        aValEdx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTX86_GETPROCESSORCPUIDLEAF_RETURN(this, hrc, 0 /*normal*/, aCpuId, aLeaf, aSubLeaf, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTX86_GETPROCESSORCPUIDLEAF_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, aLeaf, aSubLeaf, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTX86_GETPROCESSORCPUIDLEAF_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, aLeaf, aSubLeaf, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValEax=%RU32 *aValEbx=%RU32 *aValEcx=%RU32 *aValEdx=%RU32 hrc=%Rhrc\n", this, "HostX86::getProcessorCPUIDLeaf", !RT_VALID_PTR(aValEax) ? 0 : *aValEax, !RT_VALID_PTR(aValEbx) ? 0 : *aValEbx, !RT_VALID_PTR(aValEcx) ? 0 : *aValEcx, !RT_VALID_PTR(aValEdx) ? 0 : *aValEdx, hrc));
    return hrc;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod1IHostX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod2IHostX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod3IHostX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod4IHostX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod5IHostX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostX86Wrap::InternalAndReservedMethod6IHostX86()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostX86Wrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostX86Wrap, IHostX86)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostX86Wrap.cpp"


// ##### BEGINFILE "CPUProfileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICPUProfile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CPUPROFILE

#include "CPUProfileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CPUProfileWrap)

//
// ICPUProfile properties
//

STDMETHODIMP CPUProfileWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CPUProfile::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CPUProfile::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(FullName)(BSTR *aFullName)
{
    LogRelFlow(("{%p} %s: enter aFullName=%p\n", this, "CPUProfile::getFullName", aFullName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFullName);
        BSTROutConverter TmpFullName(aFullName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_FULLNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFullName(TmpFullName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_FULLNAME_RETURN(this, hrc, 0 /*normal*/,TmpFullName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_FULLNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_FULLNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFullName=%ls hrc=%Rhrc\n", this, "CPUProfile::getFullName", !RT_VALID_PTR(aFullName) ? 0 : *aFullName, hrc));
    return hrc;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(Architecture)(CPUArchitecture_T *aArchitecture)
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%p\n", this, "CPUProfile::getArchitecture", aArchitecture));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aArchitecture);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_ARCHITECTURE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getArchitecture(aArchitecture);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_ARCHITECTURE_RETURN(this, hrc, 0 /*normal*/,*aArchitecture);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_ARCHITECTURE_RETURN(this, hrc, 1 /*hrc exception*/,*aArchitecture);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CPUPROFILE_GET_ARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/,*aArchitecture);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aArchitecture=%RU32 hrc=%Rhrc\n", this, "CPUProfile::getArchitecture", !RT_VALID_PTR(aArchitecture) ? 0 : *aArchitecture, hrc));
    return hrc;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute1ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute2ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute3ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute4ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute5ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute6ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute7ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::COMGETTER(InternalAndReservedAttribute8ICPUProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICPUProfile methods
//

STDMETHODIMP CPUProfileWrap::InternalAndReservedMethod1ICPUProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::InternalAndReservedMethod2ICPUProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::InternalAndReservedMethod3ICPUProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CPUProfileWrap::InternalAndReservedMethod4ICPUProfile()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CPUProfileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CPUProfileWrap, ICPUProfile)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CPUProfileWrap.cpp"


// ##### BEGINFILE "GuestOSTypeWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestOSType.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTOSTYPE

#include "GuestOSTypeWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestOSTypeWrap)

//
// IGuestOSType properties
//

STDMETHODIMP GuestOSTypeWrap::COMGETTER(FamilyId)(BSTR *aFamilyId)
{
    LogRelFlow(("{%p} %s: enter aFamilyId=%p\n", this, "GuestOSType::getFamilyId", aFamilyId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFamilyId);
        BSTROutConverter TmpFamilyId(aFamilyId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFamilyId(TmpFamilyId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 0 /*normal*/,TmpFamilyId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFamilyId=%ls hrc=%Rhrc\n", this, "GuestOSType::getFamilyId", !RT_VALID_PTR(aFamilyId) ? 0 : *aFamilyId, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(FamilyDescription)(BSTR *aFamilyDescription)
{
    LogRelFlow(("{%p} %s: enter aFamilyDescription=%p\n", this, "GuestOSType::getFamilyDescription", aFamilyDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFamilyDescription);
        BSTROutConverter TmpFamilyDescription(aFamilyDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFamilyDescription(TmpFamilyDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpFamilyDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFamilyDescription=%ls hrc=%Rhrc\n", this, "GuestOSType::getFamilyDescription", !RT_VALID_PTR(aFamilyDescription) ? 0 : *aFamilyDescription, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestOSType::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        BSTROutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "GuestOSType::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Subtype)(BSTR *aSubtype)
{
    LogRelFlow(("{%p} %s: enter aSubtype=%p\n", this, "GuestOSType::getSubtype", aSubtype));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubtype);
        BSTROutConverter TmpSubtype(aSubtype);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_SUBTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubtype(TmpSubtype.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_SUBTYPE_RETURN(this, hrc, 0 /*normal*/,TmpSubtype.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_SUBTYPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_SUBTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubtype=%ls hrc=%Rhrc\n", this, "GuestOSType::getSubtype", !RT_VALID_PTR(aSubtype) ? 0 : *aSubtype, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "GuestOSType::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "GuestOSType::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Is64Bit)(BOOL *aIs64Bit)
{
    LogRelFlow(("{%p} %s: enter aIs64Bit=%p\n", this, "GuestOSType::getIs64Bit", aIs64Bit));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIs64Bit);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_IS64BIT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIs64Bit(aIs64Bit);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_IS64BIT_RETURN(this, hrc, 0 /*normal*/,*aIs64Bit != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_IS64BIT_RETURN(this, hrc, 1 /*hrc exception*/,*aIs64Bit != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_IS64BIT_RETURN(this, hrc, 9 /*unhandled exception*/,*aIs64Bit != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIs64Bit=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getIs64Bit", !RT_VALID_PTR(aIs64Bit) ? 0 : *aIs64Bit, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(PlatformArchitecture)(PlatformArchitecture_T *aPlatformArchitecture)
{
    LogRelFlow(("{%p} %s: enter aPlatformArchitecture=%p\n", this, "GuestOSType::getPlatformArchitecture", aPlatformArchitecture));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlatformArchitecture);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_PLATFORMARCHITECTURE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlatformArchitecture(aPlatformArchitecture);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_PLATFORMARCHITECTURE_RETURN(this, hrc, 0 /*normal*/,*aPlatformArchitecture);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_PLATFORMARCHITECTURE_RETURN(this, hrc, 1 /*hrc exception*/,*aPlatformArchitecture);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_PLATFORMARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/,*aPlatformArchitecture);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlatformArchitecture=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getPlatformArchitecture", !RT_VALID_PTR(aPlatformArchitecture) ? 0 : *aPlatformArchitecture, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedIOAPIC)(BOOL *aRecommendedIOAPIC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedIOAPIC=%p\n", this, "GuestOSType::getRecommendedIOAPIC", aRecommendedIOAPIC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedIOAPIC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOAPIC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedIOAPIC(aRecommendedIOAPIC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOAPIC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedIOAPIC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOAPIC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedIOAPIC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOAPIC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedIOAPIC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedIOAPIC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedIOAPIC", !RT_VALID_PTR(aRecommendedIOAPIC) ? 0 : *aRecommendedIOAPIC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedVirtEx)(BOOL *aRecommendedVirtEx)
{
    LogRelFlow(("{%p} %s: enter aRecommendedVirtEx=%p\n", this, "GuestOSType::getRecommendedVirtEx", aRecommendedVirtEx));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedVirtEx);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVIRTEX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedVirtEx(aRecommendedVirtEx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVIRTEX_RETURN(this, hrc, 0 /*normal*/,*aRecommendedVirtEx != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVIRTEX_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedVirtEx != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVIRTEX_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedVirtEx != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedVirtEx=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedVirtEx", !RT_VALID_PTR(aRecommendedVirtEx) ? 0 : *aRecommendedVirtEx, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedRAM)(ULONG *aRecommendedRAM)
{
    LogRelFlow(("{%p} %s: enter aRecommendedRAM=%p\n", this, "GuestOSType::getRecommendedRAM", aRecommendedRAM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedRAM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedRAM(aRecommendedRAM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 0 /*normal*/,*aRecommendedRAM);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedRAM);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedRAM);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedRAM=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedRAM", !RT_VALID_PTR(aRecommendedRAM) ? 0 : *aRecommendedRAM, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedGraphicsController)(GraphicsControllerType_T *aRecommendedGraphicsController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedGraphicsController=%p\n", this, "GuestOSType::getRecommendedGraphicsController", aRecommendedGraphicsController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedGraphicsController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedGraphicsController(aRecommendedGraphicsController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedGraphicsController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedGraphicsController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedGraphicsController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedGraphicsController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedGraphicsController", !RT_VALID_PTR(aRecommendedGraphicsController) ? 0 : *aRecommendedGraphicsController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedVRAM)(ULONG *aRecommendedVRAM)
{
    LogRelFlow(("{%p} %s: enter aRecommendedVRAM=%p\n", this, "GuestOSType::getRecommendedVRAM", aRecommendedVRAM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedVRAM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedVRAM(aRecommendedVRAM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 0 /*normal*/,*aRecommendedVRAM);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedVRAM);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedVRAM);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedVRAM=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedVRAM", !RT_VALID_PTR(aRecommendedVRAM) ? 0 : *aRecommendedVRAM, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Recommended3DAcceleration)(BOOL *aRecommended3DAcceleration)
{
    LogRelFlow(("{%p} %s: enter aRecommended3DAcceleration=%p\n", this, "GuestOSType::getRecommended3DAcceleration", aRecommended3DAcceleration));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommended3DAcceleration);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDED3DACCELERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommended3DAcceleration(aRecommended3DAcceleration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDED3DACCELERATION_RETURN(this, hrc, 0 /*normal*/,*aRecommended3DAcceleration != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDED3DACCELERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommended3DAcceleration != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDED3DACCELERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommended3DAcceleration != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommended3DAcceleration=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommended3DAcceleration", !RT_VALID_PTR(aRecommended3DAcceleration) ? 0 : *aRecommended3DAcceleration, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDD)(LONG64 *aRecommendedHDD)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDD=%p\n", this, "GuestOSType::getRecommendedHDD", aRecommendedHDD));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDD);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDD(aRecommendedHDD);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDD);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDD);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDD);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDD=%RI64 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDD", !RT_VALID_PTR(aRecommendedHDD) ? 0 : *aRecommendedHDD, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(AdapterType)(NetworkAdapterType_T *aAdapterType)
{
    LogRelFlow(("{%p} %s: enter aAdapterType=%p\n", this, "GuestOSType::getAdapterType", aAdapterType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdapterType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdapterType(aAdapterType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 0 /*normal*/,*aAdapterType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAdapterType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAdapterType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdapterType=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getAdapterType", !RT_VALID_PTR(aAdapterType) ? 0 : *aAdapterType, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedPAE)(BOOL *aRecommendedPAE)
{
    LogRelFlow(("{%p} %s: enter aRecommendedPAE=%p\n", this, "GuestOSType::getRecommendedPAE", aRecommendedPAE));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedPAE);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedPAE(aRecommendedPAE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedPAE != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedPAE != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedPAE != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedPAE=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedPAE", !RT_VALID_PTR(aRecommendedPAE) ? 0 : *aRecommendedPAE, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedDVDStorageController)(StorageControllerType_T *aRecommendedDVDStorageController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedDVDStorageController=%p\n", this, "GuestOSType::getRecommendedDVDStorageController", aRecommendedDVDStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedDVDStorageController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedDVDStorageController(aRecommendedDVDStorageController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedDVDStorageController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedDVDStorageController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedDVDStorageController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedDVDStorageController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedDVDStorageController", !RT_VALID_PTR(aRecommendedDVDStorageController) ? 0 : *aRecommendedDVDStorageController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedDVDStorageBus)(StorageBus_T *aRecommendedDVDStorageBus)
{
    LogRelFlow(("{%p} %s: enter aRecommendedDVDStorageBus=%p\n", this, "GuestOSType::getRecommendedDVDStorageBus", aRecommendedDVDStorageBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedDVDStorageBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedDVDStorageBus(aRecommendedDVDStorageBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/,*aRecommendedDVDStorageBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedDVDStorageBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedDVDStorageBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedDVDStorageBus=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedDVDStorageBus", !RT_VALID_PTR(aRecommendedDVDStorageBus) ? 0 : *aRecommendedDVDStorageBus, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDStorageController)(StorageControllerType_T *aRecommendedHDStorageController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDStorageController=%p\n", this, "GuestOSType::getRecommendedHDStorageController", aRecommendedHDStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDStorageController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDStorageController(aRecommendedHDStorageController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDStorageController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDStorageController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDStorageController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDStorageController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDStorageController", !RT_VALID_PTR(aRecommendedHDStorageController) ? 0 : *aRecommendedHDStorageController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDStorageBus)(StorageBus_T *aRecommendedHDStorageBus)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDStorageBus=%p\n", this, "GuestOSType::getRecommendedHDStorageBus", aRecommendedHDStorageBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDStorageBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDStorageBus(aRecommendedHDStorageBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDStorageBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDStorageBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDStorageBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDStorageBus=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDStorageBus", !RT_VALID_PTR(aRecommendedHDStorageBus) ? 0 : *aRecommendedHDStorageBus, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedFirmware)(FirmwareType_T *aRecommendedFirmware)
{
    LogRelFlow(("{%p} %s: enter aRecommendedFirmware=%p\n", this, "GuestOSType::getRecommendedFirmware", aRecommendedFirmware));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedFirmware);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedFirmware(aRecommendedFirmware);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedFirmware);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedFirmware);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedFirmware);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedFirmware=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedFirmware", !RT_VALID_PTR(aRecommendedFirmware) ? 0 : *aRecommendedFirmware, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSBHID)(BOOL *aRecommendedUSBHID)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSBHID=%p\n", this, "GuestOSType::getRecommendedUSBHID", aRecommendedUSBHID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSBHID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSBHID(aRecommendedUSBHID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSBHID != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSBHID != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSBHID != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSBHID=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSBHID", !RT_VALID_PTR(aRecommendedUSBHID) ? 0 : *aRecommendedUSBHID, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHPET)(BOOL *aRecommendedHPET)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHPET=%p\n", this, "GuestOSType::getRecommendedHPET", aRecommendedHPET));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHPET);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHPET(aRecommendedHPET);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHPET != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHPET != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHPET != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHPET=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHPET", !RT_VALID_PTR(aRecommendedHPET) ? 0 : *aRecommendedHPET, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSBTablet)(BOOL *aRecommendedUSBTablet)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSBTablet=%p\n", this, "GuestOSType::getRecommendedUSBTablet", aRecommendedUSBTablet));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSBTablet);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSBTablet(aRecommendedUSBTablet);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSBTablet != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSBTablet != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSBTablet != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSBTablet=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSBTablet", !RT_VALID_PTR(aRecommendedUSBTablet) ? 0 : *aRecommendedUSBTablet, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedRTCUseUTC)(BOOL *aRecommendedRTCUseUTC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedRTCUseUTC=%p\n", this, "GuestOSType::getRecommendedRTCUseUTC", aRecommendedRTCUseUTC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedRTCUseUTC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedRTCUseUTC(aRecommendedRTCUseUTC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedRTCUseUTC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedRTCUseUTC", !RT_VALID_PTR(aRecommendedRTCUseUTC) ? 0 : *aRecommendedRTCUseUTC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedChipset)(ChipsetType_T *aRecommendedChipset)
{
    LogRelFlow(("{%p} %s: enter aRecommendedChipset=%p\n", this, "GuestOSType::getRecommendedChipset", aRecommendedChipset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedChipset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedChipset(aRecommendedChipset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedChipset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedChipset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedChipset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedChipset=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedChipset", !RT_VALID_PTR(aRecommendedChipset) ? 0 : *aRecommendedChipset, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedIommuType)(IommuType_T *aRecommendedIommuType)
{
    LogRelFlow(("{%p} %s: enter aRecommendedIommuType=%p\n", this, "GuestOSType::getRecommendedIommuType", aRecommendedIommuType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedIommuType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOMMUTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedIommuType(aRecommendedIommuType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOMMUTYPE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedIommuType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOMMUTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedIommuType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDIOMMUTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedIommuType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedIommuType=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedIommuType", !RT_VALID_PTR(aRecommendedIommuType) ? 0 : *aRecommendedIommuType, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedAudioController)(AudioControllerType_T *aRecommendedAudioController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedAudioController=%p\n", this, "GuestOSType::getRecommendedAudioController", aRecommendedAudioController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedAudioController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedAudioController(aRecommendedAudioController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedAudioController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedAudioController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedAudioController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedAudioController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedAudioController", !RT_VALID_PTR(aRecommendedAudioController) ? 0 : *aRecommendedAudioController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedAudioCodec)(AudioCodecType_T *aRecommendedAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aRecommendedAudioCodec=%p\n", this, "GuestOSType::getRecommendedAudioCodec", aRecommendedAudioCodec));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedAudioCodec);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedAudioCodec(aRecommendedAudioCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedAudioCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedAudioCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedAudioCodec);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedAudioCodec=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedAudioCodec", !RT_VALID_PTR(aRecommendedAudioCodec) ? 0 : *aRecommendedAudioCodec, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedFloppy)(BOOL *aRecommendedFloppy)
{
    LogRelFlow(("{%p} %s: enter aRecommendedFloppy=%p\n", this, "GuestOSType::getRecommendedFloppy", aRecommendedFloppy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedFloppy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedFloppy(aRecommendedFloppy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 0 /*normal*/,*aRecommendedFloppy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedFloppy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedFloppy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedFloppy=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedFloppy", !RT_VALID_PTR(aRecommendedFloppy) ? 0 : *aRecommendedFloppy, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSB)(BOOL *aRecommendedUSB)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSB=%p\n", this, "GuestOSType::getRecommendedUSB", aRecommendedUSB));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSB);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSB(aRecommendedUSB);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSB != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSB != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSB != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSB=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSB", !RT_VALID_PTR(aRecommendedUSB) ? 0 : *aRecommendedUSB, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSB3)(BOOL *aRecommendedUSB3)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSB3=%p\n", this, "GuestOSType::getRecommendedUSB3", aRecommendedUSB3));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSB3);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSB3(aRecommendedUSB3);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSB3 != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSB3 != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSB3 != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSB3=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSB3", !RT_VALID_PTR(aRecommendedUSB3) ? 0 : *aRecommendedUSB3, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedTFReset)(BOOL *aRecommendedTFReset)
{
    LogRelFlow(("{%p} %s: enter aRecommendedTFReset=%p\n", this, "GuestOSType::getRecommendedTFReset", aRecommendedTFReset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedTFReset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedTFReset(aRecommendedTFReset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedTFReset != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedTFReset != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedTFReset != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedTFReset=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedTFReset", !RT_VALID_PTR(aRecommendedTFReset) ? 0 : *aRecommendedTFReset, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedX2APIC)(BOOL *aRecommendedX2APIC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedX2APIC=%p\n", this, "GuestOSType::getRecommendedX2APIC", aRecommendedX2APIC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedX2APIC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedX2APIC(aRecommendedX2APIC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedX2APIC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedX2APIC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedX2APIC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedX2APIC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedX2APIC", !RT_VALID_PTR(aRecommendedX2APIC) ? 0 : *aRecommendedX2APIC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedCPUCount)(ULONG *aRecommendedCPUCount)
{
    LogRelFlow(("{%p} %s: enter aRecommendedCPUCount=%p\n", this, "GuestOSType::getRecommendedCPUCount", aRecommendedCPUCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedCPUCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedCPUCount(aRecommendedCPUCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 0 /*normal*/,*aRecommendedCPUCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedCPUCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedCPUCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedCPUCount=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedCPUCount", !RT_VALID_PTR(aRecommendedCPUCount) ? 0 : *aRecommendedCPUCount, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedTpmType)(TpmType_T *aRecommendedTpmType)
{
    LogRelFlow(("{%p} %s: enter aRecommendedTpmType=%p\n", this, "GuestOSType::getRecommendedTpmType", aRecommendedTpmType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedTpmType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTPMTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedTpmType(aRecommendedTpmType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTPMTYPE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedTpmType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTPMTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedTpmType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTPMTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedTpmType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedTpmType=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedTpmType", !RT_VALID_PTR(aRecommendedTpmType) ? 0 : *aRecommendedTpmType, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedSecureBoot)(BOOL *aRecommendedSecureBoot)
{
    LogRelFlow(("{%p} %s: enter aRecommendedSecureBoot=%p\n", this, "GuestOSType::getRecommendedSecureBoot", aRecommendedSecureBoot));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedSecureBoot);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDSECUREBOOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedSecureBoot(aRecommendedSecureBoot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDSECUREBOOT_RETURN(this, hrc, 0 /*normal*/,*aRecommendedSecureBoot != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDSECUREBOOT_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedSecureBoot != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDSECUREBOOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedSecureBoot != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedSecureBoot=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedSecureBoot", !RT_VALID_PTR(aRecommendedSecureBoot) ? 0 : *aRecommendedSecureBoot, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedWDDMGraphics)(BOOL *aRecommendedWDDMGraphics)
{
    LogRelFlow(("{%p} %s: enter aRecommendedWDDMGraphics=%p\n", this, "GuestOSType::getRecommendedWDDMGraphics", aRecommendedWDDMGraphics));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedWDDMGraphics);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDWDDMGRAPHICS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedWDDMGraphics(aRecommendedWDDMGraphics);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDWDDMGRAPHICS_RETURN(this, hrc, 0 /*normal*/,*aRecommendedWDDMGraphics != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDWDDMGRAPHICS_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedWDDMGraphics != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDWDDMGRAPHICS_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedWDDMGraphics != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedWDDMGraphics=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedWDDMGraphics", !RT_VALID_PTR(aRecommendedWDDMGraphics) ? 0 : *aRecommendedWDDMGraphics, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(GuestAdditionsInstallPackageName)(BSTR *aGuestAdditionsInstallPackageName)
{
    LogRelFlow(("{%p} %s: enter aGuestAdditionsInstallPackageName=%p\n", this, "GuestOSType::getGuestAdditionsInstallPackageName", aGuestAdditionsInstallPackageName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestAdditionsInstallPackageName);
        BSTROutConverter TmpGuestAdditionsInstallPackageName(aGuestAdditionsInstallPackageName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_GUESTADDITIONSINSTALLPACKAGENAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestAdditionsInstallPackageName(TmpGuestAdditionsInstallPackageName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_GUESTADDITIONSINSTALLPACKAGENAME_RETURN(this, hrc, 0 /*normal*/,TmpGuestAdditionsInstallPackageName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_GUESTADDITIONSINSTALLPACKAGENAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_GUESTADDITIONSINSTALLPACKAGENAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestAdditionsInstallPackageName=%ls hrc=%Rhrc\n", this, "GuestOSType::getGuestAdditionsInstallPackageName", !RT_VALID_PTR(aGuestAdditionsInstallPackageName) ? 0 : *aGuestAdditionsInstallPackageName, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute1IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute2IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute3IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute4IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute5IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute6IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute7IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute8IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute9IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute10IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute11IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute12IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute13IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute14IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute15IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute16IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuestOSType methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestOSTypeWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestOSTypeWrap, IGuestOSType)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestOSTypeWrap.cpp"


// ##### BEGINFILE "AdditionsFacilityWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IAdditionsFacility.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_ADDITIONSFACILITY

#include "AdditionsFacilityWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(AdditionsFacilityWrap)

//
// IAdditionsFacility properties
//

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(ClassType)(AdditionsFacilityClass_T *aClassType)
{
    LogRelFlow(("{%p} %s: enter aClassType=%p\n", this, "AdditionsFacility::getClassType", aClassType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClassType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClassType(aClassType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 0 /*normal*/,*aClassType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aClassType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aClassType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClassType=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getClassType", !RT_VALID_PTR(aClassType) ? 0 : *aClassType, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(LastUpdated)(LONG64 *aLastUpdated)
{
    LogRelFlow(("{%p} %s: enter aLastUpdated=%p\n", this, "AdditionsFacility::getLastUpdated", aLastUpdated));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastUpdated);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastUpdated(aLastUpdated);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 0 /*normal*/,*aLastUpdated);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 1 /*hrc exception*/,*aLastUpdated);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 9 /*unhandled exception*/,*aLastUpdated);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastUpdated=%RI64 hrc=%Rhrc\n", this, "AdditionsFacility::getLastUpdated", !RT_VALID_PTR(aLastUpdated) ? 0 : *aLastUpdated, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "AdditionsFacility::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "AdditionsFacility::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Status)(AdditionsFacilityStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "AdditionsFacility::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Type)(AdditionsFacilityType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "AdditionsFacility::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(InternalAndReservedAttribute1IAdditionsFacility)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(InternalAndReservedAttribute2IAdditionsFacility)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IAdditionsFacility methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(AdditionsFacilityWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AdditionsFacilityWrap, IAdditionsFacility)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "AdditionsFacilityWrap.cpp"


// ##### BEGINFILE "DnDSourceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDnDSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DNDSOURCE

#include "DnDSourceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DnDSourceWrap)

//
// IDnDBase properties
//

STDMETHODIMP DnDSourceWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "DnDSource::getFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "DnDSource::getFormats", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDSource properties
//

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDnDBase methods
//

STDMETHODIMP DnDSourceWrap::IsFormatSupported(IN_BSTR aFormat,
                                              BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aSupported=%p\n", this, "DnDSource::isFormatSupported", aFormat, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        BSTRInConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_ENTER(this, TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFormatSupported(TmpFormat.str(),
                                    aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "DnDSource::isFormatSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDSource::addFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDSource::addFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDSource::removeFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDSource::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDSource methods
//

STDMETHODIMP DnDSourceWrap::DragIsPending(ULONG aScreenId,
                                          ComSafeArrayOut(BSTR, aFormats),
                                          ComSafeArrayOut(DnDAction_T, aAllowedActions),
                                          DnDAction_T *aDefaultAction)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aFormats=%p aAllowedActions=%p aDefaultAction=%p\n", this, "DnDSource::dragIsPending", aScreenId, aFormats, aAllowedActions, aDefaultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        CheckComArgOutPointerValidThrow(aAllowedActions);
        CheckComArgOutPointerValidThrow(aDefaultAction);


        
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
        ArrayOutConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayOutArg(aAllowedActions));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dragIsPending(aScreenId,
                                TmpFormats.array(),
                                TmpAllowedActions.array(),
                                aDefaultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 0 /*normal*/, aScreenId, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, *aDefaultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0, 0, 0, 0, *aDefaultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0, 0, 0, *aDefaultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu *aAllowedActions=%zu aDefaultAction=%RU32 hrc=%Rhrc\n", this, "DnDSource::dragIsPending", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), !RT_VALID_PTR(aAllowedActions) ? 0 : ComSafeArraySize(*aAllowedActions), !RT_VALID_PTR(aDefaultAction) ? 0 : *aDefaultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::Drop(IN_BSTR aFormat,
                                 DnDAction_T aAction,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aAction=%RU32 aProgress=%p\n", this, "DnDSource::drop", aFormat, aAction, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFormat(aFormat);
        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_ENTER(this, TmpFormat.str().c_str(), aAction);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = drop(TmpFormat.str(),
                       aAction,
                       TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), aAction, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAction, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAction, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "DnDSource::drop", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::ReceiveData(ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aData=%p\n", this, "DnDSource::receiveData", aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = receiveData(TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "DnDSource::receiveData", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::InternalAndReservedMethod1IDnDSource()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DnDSourceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DnDSourceWrap, IDnDSource, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DnDSourceWrap.cpp"


// ##### BEGINFILE "DnDTargetWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDnDTarget.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DNDTARGET

#include "DnDTargetWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DnDTargetWrap)

//
// IDnDBase properties
//

STDMETHODIMP DnDTargetWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "DnDTarget::getFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "DnDTarget::getFormats", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDTarget properties
//

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDnDBase methods
//

STDMETHODIMP DnDTargetWrap::IsFormatSupported(IN_BSTR aFormat,
                                              BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aSupported=%p\n", this, "DnDTarget::isFormatSupported", aFormat, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        BSTRInConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_ENTER(this, TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFormatSupported(TmpFormat.str(),
                                    aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "DnDTarget::isFormatSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDTarget::addFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::addFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDTarget::removeFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDTarget methods
//

STDMETHODIMP DnDTargetWrap::Enter(ULONG aScreenId,
                                  ULONG aY,
                                  ULONG aX,
                                  DnDAction_T aDefaultAction,
                                  ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                  ComSafeArrayIn(IN_BSTR, aFormats),
                                  DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aY=%RU32 aX=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aResultAction=%p\n", this, "DnDTarget::enter", aScreenId, aY, aX, aDefaultAction, aAllowedActions, aFormats, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_ENTER(this, aScreenId, aY, aX, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enter(aScreenId,
                        aY,
                        aX,
                        aDefaultAction,
                        TmpAllowedActions.array(),
                        TmpFormats.array(),
                        aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 0 /*normal*/, aScreenId, aY, aX, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aY, aX, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aY, aX, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::enter", !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Move(ULONG aScreenId,
                                 ULONG aX,
                                 ULONG aY,
                                 DnDAction_T aDefaultAction,
                                 ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                 ComSafeArrayIn(IN_BSTR, aFormats),
                                 DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aX=%RU32 aY=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aResultAction=%p\n", this, "DnDTarget::move", aScreenId, aX, aY, aDefaultAction, aAllowedActions, aFormats, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_ENTER(this, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = move(aScreenId,
                       aX,
                       aY,
                       aDefaultAction,
                       TmpAllowedActions.array(),
                       TmpFormats.array(),
                       aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::move", !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Leave(ULONG aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32\n", this, "DnDTarget::leave", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = leave(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 0 /*normal*/, aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::leave", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Drop(ULONG aScreenId,
                                 ULONG aX,
                                 ULONG aY,
                                 DnDAction_T aDefaultAction,
                                 ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                 ComSafeArrayIn(IN_BSTR, aFormats),
                                 BSTR *aFormat,
                                 DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aX=%RU32 aY=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aFormat=%p aResultAction=%p\n", this, "DnDTarget::drop", aScreenId, aX, aY, aDefaultAction, aAllowedActions, aFormats, aFormat, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormat);
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        BSTROutConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_ENTER(this, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = drop(aScreenId,
                       aX,
                       aY,
                       aDefaultAction,
                       TmpAllowedActions.array(),
                       TmpFormats.array(),
                       TmpFormat.str(),
                       aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 0 /*normal*/, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, TmpFormat.str().c_str(), *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormat=%ls aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::drop", !RT_VALID_PTR(aFormat) ? 0 : *aFormat, !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::SendData(ULONG aScreenId,
                                     IN_BSTR aFormat,
                                     ComSafeArrayIn(BYTE, aData),
                                     IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aFormat=%ls aData=%zu aProgress=%p\n", this, "DnDTarget::sendData", aScreenId, aFormat, aData, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        
        BSTRInConverter TmpFormat(aFormat);
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_ENTER(this, aScreenId, TmpFormat.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = sendData(aScreenId,
                           TmpFormat.str(),
                           TmpData.array(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 0 /*normal*/, aScreenId, TmpFormat.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "DnDTarget::sendData", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Cancel(BOOL *aVeto)
{
    LogRelFlow(("{%p} %s: enter aVeto=%p\n", this, "DnDTarget::cancel", aVeto));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVeto);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancel(aVeto);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 0 /*normal*/, *aVeto != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 1 /*hrc exception*/, *aVeto != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 9 /*unhandled exception*/, *aVeto != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aVeto=%RTbool hrc=%Rhrc\n", this, "DnDTarget::cancel", !RT_VALID_PTR(aVeto) ? 0 : *aVeto, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::InternalAndReservedMethod1IDnDTarget()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DnDTargetWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DnDTargetWrap, IDnDTarget, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DnDTargetWrap.cpp"


// ##### BEGINFILE "GuestSessionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestSession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTSESSION

#include "GuestSessionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestSessionWrap)

//
// IGuestSession properties
//

STDMETHODIMP GuestSessionWrap::COMGETTER(User)(BSTR *aUser)
{
    LogRelFlow(("{%p} %s: enter aUser=%p\n", this, "GuestSession::getUser", aUser));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUser);
        BSTROutConverter TmpUser(aUser);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUser(TmpUser.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 0 /*normal*/,TmpUser.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUser=%ls hrc=%Rhrc\n", this, "GuestSession::getUser", !RT_VALID_PTR(aUser) ? 0 : *aUser, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Domain)(BSTR *aDomain)
{
    LogRelFlow(("{%p} %s: enter aDomain=%p\n", this, "GuestSession::getDomain", aDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDomain);
        BSTROutConverter TmpDomain(aDomain);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDomain(TmpDomain.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 0 /*normal*/,TmpDomain.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDomain=%ls hrc=%Rhrc\n", this, "GuestSession::getDomain", !RT_VALID_PTR(aDomain) ? 0 : *aDomain, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestSession::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestSession::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestSession::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,*aId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "GuestSession::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Timeout)(ULONG *aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%p\n", this, "GuestSession::getTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeout=%RU32 hrc=%Rhrc\n", this, "GuestSession::getTimeout", !RT_VALID_PTR(aTimeout) ? 0 : *aTimeout, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(Timeout)(ULONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RU32\n", this, "GuestSession::setTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setTimeout", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(ProtocolVersion)(ULONG *aProtocolVersion)
{
    LogRelFlow(("{%p} %s: enter aProtocolVersion=%p\n", this, "GuestSession::getProtocolVersion", aProtocolVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProtocolVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProtocolVersion(aProtocolVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 0 /*normal*/,*aProtocolVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aProtocolVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aProtocolVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProtocolVersion=%RU32 hrc=%Rhrc\n", this, "GuestSession::getProtocolVersion", !RT_VALID_PTR(aProtocolVersion) ? 0 : *aProtocolVersion, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Status)(GuestSessionStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestSession::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestSession::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EnvironmentChanges)(ComSafeArrayOut(BSTR, aEnvironmentChanges))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentChanges=%p\n", this, "GuestSession::getEnvironmentChanges", aEnvironmentChanges));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironmentChanges);
        ArrayBSTROutConverter TmpEnvironmentChanges(ComSafeArrayOutArg(aEnvironmentChanges));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironmentChanges(TmpEnvironmentChanges.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironmentChanges=%zu hrc=%Rhrc\n", this, "GuestSession::getEnvironmentChanges", !RT_VALID_PTR(aEnvironmentChanges) ? 0 : ComSafeArraySize(*aEnvironmentChanges), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(EnvironmentChanges)(ComSafeArrayIn(IN_BSTR, aEnvironmentChanges))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentChanges=%zu\n", this, "GuestSession::setEnvironmentChanges", ComSafeArraySize(aEnvironmentChanges)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_ENTER(this, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnvironmentChanges(TmpEnvironmentChanges.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setEnvironmentChanges", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EnvironmentBase)(ComSafeArrayOut(BSTR, aEnvironmentBase))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentBase=%p\n", this, "GuestSession::getEnvironmentBase", aEnvironmentBase));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironmentBase);
        ArrayBSTROutConverter TmpEnvironmentBase(ComSafeArrayOutArg(aEnvironmentBase));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironmentBase(TmpEnvironmentBase.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentBase.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironmentBase=%zu hrc=%Rhrc\n", this, "GuestSession::getEnvironmentBase", !RT_VALID_PTR(aEnvironmentBase) ? 0 : ComSafeArraySize(*aEnvironmentBase), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Processes)(ComSafeArrayOut(IGuestProcess *, aProcesses))
{
    LogRelFlow(("{%p} %s: enter aProcesses=%p\n", this, "GuestSession::getProcesses", aProcesses));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProcesses);
        ArrayComTypeOutConverter<IGuestProcess> TmpProcesses(ComSafeArrayOutArg(aProcesses));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcesses(TmpProcesses.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProcesses.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcesses=%zu hrc=%Rhrc\n", this, "GuestSession::getProcesses", !RT_VALID_PTR(aProcesses) ? 0 : ComSafeArraySize(*aProcesses), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(PathStyle)(PathStyle_T *aPathStyle)
{
    LogRelFlow(("{%p} %s: enter aPathStyle=%p\n", this, "GuestSession::getPathStyle", aPathStyle));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPathStyle);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPathStyle(aPathStyle);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 0 /*normal*/,*aPathStyle);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 1 /*hrc exception*/,*aPathStyle);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aPathStyle);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPathStyle=%RU32 hrc=%Rhrc\n", this, "GuestSession::getPathStyle", !RT_VALID_PTR(aPathStyle) ? 0 : *aPathStyle, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(CurrentDirectory)(BSTR *aCurrentDirectory)
{
    LogRelFlow(("{%p} %s: enter aCurrentDirectory=%p\n", this, "GuestSession::getCurrentDirectory", aCurrentDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCurrentDirectory);
        BSTROutConverter TmpCurrentDirectory(aCurrentDirectory);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCurrentDirectory(TmpCurrentDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 0 /*normal*/,TmpCurrentDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCurrentDirectory=%ls hrc=%Rhrc\n", this, "GuestSession::getCurrentDirectory", !RT_VALID_PTR(aCurrentDirectory) ? 0 : *aCurrentDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(CurrentDirectory)(IN_BSTR aCurrentDirectory)
{
    LogRelFlow(("{%p} %s: enter aCurrentDirectory=%ls\n", this, "GuestSession::setCurrentDirectory", aCurrentDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpCurrentDirectory(aCurrentDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_ENTER(this, TmpCurrentDirectory.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCurrentDirectory(TmpCurrentDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 0 /*normal*/,TmpCurrentDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setCurrentDirectory", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(UserHome)(BSTR *aUserHome)
{
    LogRelFlow(("{%p} %s: enter aUserHome=%p\n", this, "GuestSession::getUserHome", aUserHome));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserHome);
        BSTROutConverter TmpUserHome(aUserHome);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserHome(TmpUserHome.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 0 /*normal*/,TmpUserHome.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserHome=%ls hrc=%Rhrc\n", this, "GuestSession::getUserHome", !RT_VALID_PTR(aUserHome) ? 0 : *aUserHome, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(UserDocuments)(BSTR *aUserDocuments)
{
    LogRelFlow(("{%p} %s: enter aUserDocuments=%p\n", this, "GuestSession::getUserDocuments", aUserDocuments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserDocuments);
        BSTROutConverter TmpUserDocuments(aUserDocuments);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserDocuments(TmpUserDocuments.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 0 /*normal*/,TmpUserDocuments.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserDocuments=%ls hrc=%Rhrc\n", this, "GuestSession::getUserDocuments", !RT_VALID_PTR(aUserDocuments) ? 0 : *aUserDocuments, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(MountPoints)(ComSafeArrayOut(BSTR, aMountPoints))
{
    LogRelFlow(("{%p} %s: enter aMountPoints=%p\n", this, "GuestSession::getMountPoints", aMountPoints));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMountPoints);
        ArrayBSTROutConverter TmpMountPoints(ComSafeArrayOutArg(aMountPoints));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_MOUNTPOINTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMountPoints(TmpMountPoints.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_MOUNTPOINTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMountPoints.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_MOUNTPOINTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_MOUNTPOINTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMountPoints=%zu hrc=%Rhrc\n", this, "GuestSession::getMountPoints", !RT_VALID_PTR(aMountPoints) ? 0 : ComSafeArraySize(*aMountPoints), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Directories)(ComSafeArrayOut(IGuestDirectory *, aDirectories))
{
    LogRelFlow(("{%p} %s: enter aDirectories=%p\n", this, "GuestSession::getDirectories", aDirectories));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectories);
        ArrayComTypeOutConverter<IGuestDirectory> TmpDirectories(ComSafeArrayOutArg(aDirectories));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDirectories(TmpDirectories.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDirectories.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectories=%zu hrc=%Rhrc\n", this, "GuestSession::getDirectories", !RT_VALID_PTR(aDirectories) ? 0 : ComSafeArraySize(*aDirectories), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Files)(ComSafeArrayOut(IGuestFile *, aFiles))
{
    LogRelFlow(("{%p} %s: enter aFiles=%p\n", this, "GuestSession::getFiles", aFiles));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFiles);
        ArrayComTypeOutConverter<IGuestFile> TmpFiles(ComSafeArrayOutArg(aFiles));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFiles(TmpFiles.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFiles.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFiles=%zu hrc=%Rhrc\n", this, "GuestSession::getFiles", !RT_VALID_PTR(aFiles) ? 0 : ComSafeArraySize(*aFiles), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestSession::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestSession::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute1IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute2IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute3IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute4IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute5IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute6IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute7IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute8IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute9IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute10IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute11IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute12IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuestSession methods
//

STDMETHODIMP GuestSessionWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestSession::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::close", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::CopyFromGuest(ComSafeArrayIn(IN_BSTR, aSources),
                                             ComSafeArrayIn(IN_BSTR, aFilters),
                                             ComSafeArrayIn(IN_BSTR, aFlags),
                                             IN_BSTR aDestination,
                                             IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSources=%zu aFilters=%zu aFlags=%zu aDestination=%ls aProgress=%p\n", this, "GuestSession::copyFromGuest", aSources, aFilters, aFlags, aDestination, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSources(ComSafeArrayInArg(aSources));
        ArrayBSTRInConverter TmpFilters(ComSafeArrayInArg(aFilters));
        ArrayBSTRInConverter TmpFlags(ComSafeArrayInArg(aFlags));
        BSTRInConverter TmpDestination(aDestination);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_ENTER(this, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = copyFromGuest(TmpSources.array(),
                                TmpFilters.array(),
                                TmpFlags.array(),
                                TmpDestination.str(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::copyFromGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::CopyToGuest(ComSafeArrayIn(IN_BSTR, aSources),
                                           ComSafeArrayIn(IN_BSTR, aFilters),
                                           ComSafeArrayIn(IN_BSTR, aFlags),
                                           IN_BSTR aDestination,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSources=%zu aFilters=%zu aFlags=%zu aDestination=%ls aProgress=%p\n", this, "GuestSession::copyToGuest", aSources, aFilters, aFlags, aDestination, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSources(ComSafeArrayInArg(aSources));
        ArrayBSTRInConverter TmpFilters(ComSafeArrayInArg(aFilters));
        ArrayBSTRInConverter TmpFlags(ComSafeArrayInArg(aFlags));
        BSTRInConverter TmpDestination(aDestination);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_ENTER(this, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = copyToGuest(TmpSources.array(),
                              TmpFilters.array(),
                              TmpFlags.array(),
                              TmpDestination.str(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::copyToGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopy(IN_BSTR aSource,
                                             IN_BSTR aDestination,
                                             ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                             IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopy", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopy(TmpSource.str(),
                                TmpDestination.str(),
                                TmpFlags.array(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopy", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopyFromGuest(IN_BSTR aSource,
                                                      IN_BSTR aDestination,
                                                      ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopyFromGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopyFromGuest(TmpSource.str(),
                                         TmpDestination.str(),
                                         TmpFlags.array(),
                                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopyFromGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopyToGuest(IN_BSTR aSource,
                                                    IN_BSTR aDestination,
                                                    ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                                    IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopyToGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopyToGuest(TmpSource.str(),
                                       TmpDestination.str(),
                                       TmpFlags.array(),
                                       TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopyToGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCreate(IN_BSTR aPath,
                                               ULONG aMode,
                                               ComSafeArrayIn(DirectoryCreateFlag_T, aFlags))
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aMode=%RU32 aFlags=%zu\n", this, "GuestSession::directoryCreate", aPath, aMode, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);
        
        ArrayInConverter<DirectoryCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_ENTER(this, TmpPath.str().c_str(), aMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCreate(TmpPath.str(),
                                  aMode,
                                  TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::directoryCreate", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCreateTemp(IN_BSTR aTemplateName,
                                                   ULONG aMode,
                                                   IN_BSTR aPath,
                                                   BOOL aSecure,
                                                   BSTR *aDirectory)
{
    LogRelFlow(("{%p} %s: enter aTemplateName=%ls aMode=%RU32 aPath=%ls aSecure=%RTbool aDirectory=%p\n", this, "GuestSession::directoryCreateTemp", aTemplateName, aMode, aPath, aSecure, aDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectory);


        BSTRInConverter TmpTemplateName(aTemplateName);
        
        BSTRInConverter TmpPath(aPath);
        
        BSTROutConverter TmpDirectory(aDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_ENTER(this, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCreateTemp(TmpTemplateName.str(),
                                      aMode,
                                      TmpPath.str(),
                                      aSecure != FALSE,
                                      TmpDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 0 /*normal*/, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE, TmpDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDirectory=%ls hrc=%Rhrc\n", this, "GuestSession::directoryCreateTemp", !RT_VALID_PTR(aDirectory) ? 0 : *aDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryExists(IN_BSTR aPath,
                                               BOOL aFollowSymlinks,
                                               BOOL *aExists)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::directoryExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryExists(TmpPath.str(),
                                  aFollowSymlinks != FALSE,
                                  aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::directoryExists", !RT_VALID_PTR(aExists) ? 0 : *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryOpen(IN_BSTR aPath,
                                             IN_BSTR aFilter,
                                             ComSafeArrayIn(DirectoryOpenFlag_T, aFlags),
                                             IGuestDirectory **aDirectory)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFilter=%ls aFlags=%zu aDirectory=%p\n", this, "GuestSession::directoryOpen", aPath, aFilter, aFlags, aDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectory);


        BSTRInConverter TmpPath(aPath);
        BSTRInConverter TmpFilter(aFilter);
        ArrayInConverter<DirectoryOpenFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IGuestDirectory> TmpDirectory(aDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_ENTER(this, TmpPath.str().c_str(), TmpFilter.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryOpen(TmpPath.str(),
                                TmpFilter.str(),
                                TmpFlags.array(),
                                TmpDirectory.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), TmpFilter.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpDirectory.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDirectory=%p hrc=%Rhrc\n", this, "GuestSession::directoryOpen", !RT_VALID_PTR(aDirectory) ? 0 : *aDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryRemove(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "GuestSession::directoryRemove", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryRemove(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::directoryRemove", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryRemoveRecursive(IN_BSTR aPath,
                                                        ComSafeArrayIn(DirectoryRemoveRecFlag_T, aFlags),
                                                        IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryRemoveRecursive", aPath, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpPath(aPath);
        ArrayInConverter<DirectoryRemoveRecFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_ENTER(this, TmpPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryRemoveRecursive(TmpPath.str(),
                                           TmpFlags.array(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryRemoveRecursive", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentScheduleSet(IN_BSTR aName,
                                                      IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%ls\n", this, "GuestSession::environmentScheduleSet", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentScheduleSet(TmpName.str(),
                                         TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::environmentScheduleSet", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentScheduleUnset(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "GuestSession::environmentScheduleUnset", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentScheduleUnset(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::environmentScheduleUnset", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentGetBaseVariable(IN_BSTR aName,
                                                          BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%p\n", this, "GuestSession::environmentGetBaseVariable", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentGetBaseVariable(TmpName.str(),
                                             TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "GuestSession::environmentGetBaseVariable", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentDoesBaseVariableExist(IN_BSTR aName,
                                                                BOOL *aExists)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aExists=%p\n", this, "GuestSession::environmentDoesBaseVariableExist", aName, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpName(aName);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentDoesBaseVariableExist(TmpName.str(),
                                                   aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::environmentDoesBaseVariableExist", !RT_VALID_PTR(aExists) ? 0 : *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopy(IN_BSTR aSource,
                                        IN_BSTR aDestination,
                                        ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                        IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopy", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopy(TmpSource.str(),
                           TmpDestination.str(),
                           TmpFlags.array(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopy", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopyFromGuest(IN_BSTR aSource,
                                                 IN_BSTR aDestination,
                                                 ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopyFromGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopyFromGuest(TmpSource.str(),
                                    TmpDestination.str(),
                                    TmpFlags.array(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopyFromGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopyToGuest(IN_BSTR aSource,
                                               IN_BSTR aDestination,
                                               ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                               IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopyToGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopyToGuest(TmpSource.str(),
                                  TmpDestination.str(),
                                  TmpFlags.array(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopyToGuest", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCreateTemp(IN_BSTR aTemplateName,
                                              ULONG aMode,
                                              IN_BSTR aPath,
                                              BOOL aSecure,
                                              IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aTemplateName=%ls aMode=%RU32 aPath=%ls aSecure=%RTbool aFile=%p\n", this, "GuestSession::fileCreateTemp", aTemplateName, aMode, aPath, aSecure, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpTemplateName(aTemplateName);
        
        BSTRInConverter TmpPath(aPath);
        
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_ENTER(this, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCreateTemp(TmpTemplateName.str(),
                                 aMode,
                                 TmpPath.str(),
                                 aSecure != FALSE,
                                 TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 0 /*normal*/, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileCreateTemp", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileExists(IN_BSTR aPath,
                                          BOOL aFollowSymlinks,
                                          BOOL *aExists)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::fileExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileExists(TmpPath.str(),
                             aFollowSymlinks != FALSE,
                             aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::fileExists", !RT_VALID_PTR(aExists) ? 0 : *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileOpen(IN_BSTR aPath,
                                        FileAccessMode_T aAccessMode,
                                        FileOpenAction_T aOpenAction,
                                        ULONG aCreationMode,
                                        IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aAccessMode=%RU32 aOpenAction=%RU32 aCreationMode=%RU32 aFile=%p\n", this, "GuestSession::fileOpen", aPath, aAccessMode, aOpenAction, aCreationMode, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpPath(aPath);
        
        
        
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_ENTER(this, TmpPath.str().c_str(), aAccessMode, aOpenAction, aCreationMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileOpen(TmpPath.str(),
                           aAccessMode,
                           aOpenAction,
                           aCreationMode,
                           TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aAccessMode, aOpenAction, aCreationMode, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAccessMode, aOpenAction, aCreationMode, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAccessMode, aOpenAction, aCreationMode, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileOpen", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileOpenEx(IN_BSTR aPath,
                                          FileAccessMode_T aAccessMode,
                                          FileOpenAction_T aOpenAction,
                                          FileSharingMode_T aSharingMode,
                                          ULONG aCreationMode,
                                          ComSafeArrayIn(FileOpenExFlag_T, aFlags),
                                          IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aAccessMode=%RU32 aOpenAction=%RU32 aSharingMode=%RU32 aCreationMode=%RU32 aFlags=%zu aFile=%p\n", this, "GuestSession::fileOpenEx", aPath, aAccessMode, aOpenAction, aSharingMode, aCreationMode, aFlags, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpPath(aPath);
        
        
        
        
        ArrayInConverter<FileOpenExFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_ENTER(this, TmpPath.str().c_str(), aAccessMode, aOpenAction, aSharingMode, aCreationMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileOpenEx(TmpPath.str(),
                             aAccessMode,
                             aOpenAction,
                             aSharingMode,
                             aCreationMode,
                             TmpFlags.array(),
                             TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aAccessMode, aOpenAction, aSharingMode, aCreationMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAccessMode, aOpenAction, aSharingMode, aCreationMode, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAccessMode, aOpenAction, aSharingMode, aCreationMode, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileOpenEx", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileQuerySize(IN_BSTR aPath,
                                             BOOL aFollowSymlinks,
                                             LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aSize=%p\n", this, "GuestSession::fileQuerySize", aPath, aFollowSymlinks, aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSize);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileQuerySize(TmpPath.str(),
                                aFollowSymlinks != FALSE,
                                aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSize=%RI64 hrc=%Rhrc\n", this, "GuestSession::fileQuerySize", !RT_VALID_PTR(aSize) ? 0 : *aSize, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjExists(IN_BSTR aPath,
                                           BOOL aFollowSymlinks,
                                           BOOL *aExists)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::fsObjExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjExists(TmpPath.str(),
                              aFollowSymlinks != FALSE,
                              aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::fsObjExists", !RT_VALID_PTR(aExists) ? 0 : *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjQueryInfo(IN_BSTR aPath,
                                              BOOL aFollowSymlinks,
                                              IGuestFsObjInfo **aInfo)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aInfo=%p\n", this, "GuestSession::fsObjQueryInfo", aPath, aFollowSymlinks, aInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInfo);


        BSTRInConverter TmpPath(aPath);
        
        ComTypeOutConverter<IGuestFsObjInfo> TmpInfo(aInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjQueryInfo(TmpPath.str(),
                                 aFollowSymlinks != FALSE,
                                 TmpInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, (void *)TmpInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aInfo=%p hrc=%Rhrc\n", this, "GuestSession::fsObjQueryInfo", !RT_VALID_PTR(aInfo) ? 0 : *aInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRemove(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "GuestSession::fsObjRemove", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRemove(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjRemove", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRemoveArray(ComSafeArrayIn(IN_BSTR, aPath),
                                                IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aPath=%zu aProgress=%p\n", this, "GuestSession::fsObjRemoveArray", aPath, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpPath(ComSafeArrayInArg(aPath));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_ENTER(this, (uint32_t)TmpPath.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRemoveArray(TmpPath.array(),
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpPath.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjRemoveArray", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRename(IN_BSTR aOldPath,
                                           IN_BSTR aNewPath,
                                           ComSafeArrayIn(FsObjRenameFlag_T, aFlags))
{
    LogRelFlow(("{%p} %s: enter aOldPath=%ls aNewPath=%ls aFlags=%zu\n", this, "GuestSession::fsObjRename", aOldPath, aNewPath, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpOldPath(aOldPath);
        BSTRInConverter TmpNewPath(aNewPath);
        ArrayInConverter<FsObjRenameFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_ENTER(this, TmpOldPath.str().c_str(), TmpNewPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRename(TmpOldPath.str(),
                              TmpNewPath.str(),
                              TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 0 /*normal*/, TmpOldPath.str().c_str(), TmpNewPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjRename", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjMove(IN_BSTR aSource,
                                         IN_BSTR aDestination,
                                         ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                                         IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjMove", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FsObjMoveFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjMove(TmpSource.str(),
                            TmpDestination.str(),
                            TmpFlags.array(),
                            TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjMove", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjMoveArray(ComSafeArrayIn(IN_BSTR, aSource),
                                              IN_BSTR aDestination,
                                              ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%zu aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjMoveArray", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSource(ComSafeArrayInArg(aSource));
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FsObjMoveFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_ENTER(this, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjMoveArray(TmpSource.array(),
                                 TmpDestination.str(),
                                 TmpFlags.array(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjMoveArray", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjCopyArray(ComSafeArrayIn(IN_BSTR, aSource),
                                              IN_BSTR aDestination,
                                              ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%zu aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjCopyArray", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSource(ComSafeArrayInArg(aSource));
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_ENTER(this, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjCopyArray(TmpSource.array(),
                                 TmpDestination.str(),
                                 TmpFlags.array(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjCopyArray", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjSetACL(IN_BSTR aPath,
                                           BOOL aFollowSymlinks,
                                           IN_BSTR aAcl,
                                           ULONG aMode)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFollowSymlinks=%RTbool aAcl=%ls aMode=%RU32\n", this, "GuestSession::fsObjSetACL", aPath, aFollowSymlinks, aAcl, aMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);
        
        BSTRInConverter TmpAcl(aAcl);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE, TmpAcl.str().c_str(), aMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjSetACL(TmpPath.str(),
                              aFollowSymlinks != FALSE,
                              TmpAcl.str(),
                              aMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, TmpAcl.str().c_str(), aMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, 0, aMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, 0, aMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjSetACL", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsQueryFreeSpace(IN_BSTR aPath,
                                                LONG64 *aFreeSpace)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFreeSpace=%p\n", this, "GuestSession::fsQueryFreeSpace", aPath, aFreeSpace));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeSpace);


        BSTRInConverter TmpPath(aPath);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYFREESPACE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsQueryFreeSpace(TmpPath.str(),
                                   aFreeSpace);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYFREESPACE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), *aFreeSpace);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYFREESPACE_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aFreeSpace);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYFREESPACE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aFreeSpace);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFreeSpace=%RI64 hrc=%Rhrc\n", this, "GuestSession::fsQueryFreeSpace", !RT_VALID_PTR(aFreeSpace) ? 0 : *aFreeSpace, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsQueryInfo(IN_BSTR aPath,
                                           IGuestFsInfo **aInfo)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aInfo=%p\n", this, "GuestSession::fsQueryInfo", aPath, aInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInfo);


        BSTRInConverter TmpPath(aPath);
        ComTypeOutConverter<IGuestFsInfo> TmpInfo(aInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYINFO_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsQueryInfo(TmpPath.str(),
                              TmpInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYINFO_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), (void *)TmpInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSQUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aInfo=%p hrc=%Rhrc\n", this, "GuestSession::fsQueryInfo", !RT_VALID_PTR(aInfo) ? 0 : *aInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessCreate(IN_BSTR aExecutable,
                                             ComSafeArrayIn(IN_BSTR, aArguments),
                                             IN_BSTR aCwd,
                                             ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                                             ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                                             ULONG aTimeoutMS,
                                             IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s: enter aExecutable=%ls aArguments=%zu aCwd=%ls aEnvironmentChanges=%zu aFlags=%zu aTimeoutMS=%RU32 aGuestProcess=%p\n", this, "GuestSession::processCreate", aExecutable, aArguments, aCwd, aEnvironmentChanges, aFlags, aTimeoutMS, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        BSTRInConverter TmpExecutable(aExecutable);
        ArrayBSTRInConverter TmpArguments(ComSafeArrayInArg(aArguments));
        BSTRInConverter TmpCwd(aCwd);
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));
        ArrayInConverter<ProcessCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_ENTER(this, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, TmpCwd.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = processCreate(TmpExecutable.str(),
                                TmpArguments.array(),
                                TmpCwd.str(),
                                TmpEnvironmentChanges.array(),
                                TmpFlags.array(),
                                aTimeoutMS,
                                TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 0 /*normal*/, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, TmpCwd.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processCreate", !RT_VALID_PTR(aGuestProcess) ? 0 : *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessCreateEx(IN_BSTR aExecutable,
                                               ComSafeArrayIn(IN_BSTR, aArguments),
                                               IN_BSTR aCwd,
                                               ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                                               ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                                               ULONG aTimeoutMS,
                                               ProcessPriority_T aPriority,
                                               ComSafeArrayIn(LONG, aAffinity),
                                               IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s: enter aExecutable=%ls aArguments=%zu aCwd=%ls aEnvironmentChanges=%zu aFlags=%zu aTimeoutMS=%RU32 aPriority=%RU32 aAffinity=%zu aGuestProcess=%p\n", this, "GuestSession::processCreateEx", aExecutable, aArguments, aCwd, aEnvironmentChanges, aFlags, aTimeoutMS, aPriority, aAffinity, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        BSTRInConverter TmpExecutable(aExecutable);
        ArrayBSTRInConverter TmpArguments(ComSafeArrayInArg(aArguments));
        BSTRInConverter TmpCwd(aCwd);
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));
        ArrayInConverter<ProcessCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        
        
        ArrayInConverter<LONG> TmpAffinity(ComSafeArrayInArg(aAffinity));
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_ENTER(this, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, TmpCwd.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, aPriority, (uint32_t)TmpAffinity.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = processCreateEx(TmpExecutable.str(),
                                  TmpArguments.array(),
                                  TmpCwd.str(),
                                  TmpEnvironmentChanges.array(),
                                  TmpFlags.array(),
                                  aTimeoutMS,
                                  aPriority,
                                  TmpAffinity.array(),
                                  TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 0 /*normal*/, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, TmpCwd.str().c_str(), (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, aPriority, (uint32_t)TmpAffinity.array().size(), NULL /*for now*/, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, aPriority, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, aPriority, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processCreateEx", !RT_VALID_PTR(aGuestProcess) ? 0 : *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessGet(ULONG aPid,
                                          IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s: enter aPid=%RU32 aGuestProcess=%p\n", this, "GuestSession::processGet", aPid, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_ENTER(this, aPid);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = processGet(aPid,
                             TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 0 /*normal*/, aPid, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 1 /*hrc exception*/, aPid, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 9 /*unhandled exception*/, aPid, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processGet", !RT_VALID_PTR(aGuestProcess) ? 0 : *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkCreate(IN_BSTR aSymlink,
                                             IN_BSTR aTarget,
                                             SymlinkType_T aType)
{
    LogRelFlow(("{%p} %s: enter aSymlink=%ls aTarget=%ls aType=%RU32\n", this, "GuestSession::symlinkCreate", aSymlink, aTarget, aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSymlink(aSymlink);
        BSTRInConverter TmpTarget(aTarget);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_ENTER(this, TmpSymlink.str().c_str(), TmpTarget.str().c_str(), aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkCreate(TmpSymlink.str(),
                                TmpTarget.str(),
                                aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), TmpTarget.str().c_str(), aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::symlinkCreate", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkExists(IN_BSTR aSymlink,
                                             BOOL *aExists)
{
    LogRelFlow(("{%p} %s: enter aSymlink=%ls aExists=%p\n", this, "GuestSession::symlinkExists", aSymlink, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpSymlink(aSymlink);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_ENTER(this, TmpSymlink.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkExists(TmpSymlink.str(),
                                aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::symlinkExists", !RT_VALID_PTR(aExists) ? 0 : *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkRead(IN_BSTR aSymlink,
                                           ComSafeArrayIn(SymlinkReadFlag_T, aFlags),
                                           BSTR *aTarget)
{
    LogRelFlow(("{%p} %s: enter aSymlink=%ls aFlags=%zu aTarget=%p\n", this, "GuestSession::symlinkRead", aSymlink, aFlags, aTarget));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTarget);


        BSTRInConverter TmpSymlink(aSymlink);
        ArrayInConverter<SymlinkReadFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        BSTROutConverter TmpTarget(aTarget);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_ENTER(this, TmpSymlink.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkRead(TmpSymlink.str(),
                              TmpFlags.array(),
                              TmpTarget.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpTarget.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aTarget=%ls hrc=%Rhrc\n", this, "GuestSession::symlinkRead", !RT_VALID_PTR(aTarget) ? 0 : *aTarget, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::WaitFor(ULONG aWaitFor,
                                       ULONG aTimeoutMS,
                                       GuestSessionWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%RU32 aTimeoutMS=%RU32 aReason=%p\n", this, "GuestSession::waitFor", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_ENTER(this, aWaitFor, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitFor(aWaitFor,
                          aTimeoutMS,
                          aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 0 /*normal*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 1 /*hrc exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 9 /*unhandled exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestSession::waitFor", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::WaitForArray(ComSafeArrayIn(GuestSessionWaitForFlag_T, aWaitFor),
                                            ULONG aTimeoutMS,
                                            GuestSessionWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%zu aTimeoutMS=%RU32 aReason=%p\n", this, "GuestSession::waitForArray", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        ArrayInConverter<GuestSessionWaitForFlag_T> TmpWaitFor(ComSafeArrayInArg(aWaitFor));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_ENTER(this, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForArray(TmpWaitFor.array(),
                               aTimeoutMS,
                               aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestSession::waitForArray", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod1IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod2IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod3IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod4IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod5IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod6IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod7IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod8IGuestSession()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestSessionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestSessionWrap, IGuestSession)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestSessionWrap.cpp"


// ##### BEGINFILE "GuestProcessWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestProcess.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTPROCESS

#include "GuestProcessWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestProcessWrap)

//
// IProcess properties
//

STDMETHODIMP GuestProcessWrap::COMGETTER(Arguments)(ComSafeArrayOut(BSTR, aArguments))
{
    LogRelFlow(("{%p} %s: enter aArguments=%p\n", this, "GuestProcess::getArguments", aArguments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aArguments);
        ArrayBSTROutConverter TmpArguments(ComSafeArrayOutArg(aArguments));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getArguments(TmpArguments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpArguments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aArguments=%zu hrc=%Rhrc\n", this, "GuestProcess::getArguments", !RT_VALID_PTR(aArguments) ? 0 : ComSafeArraySize(*aArguments), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))
{
    LogRelFlow(("{%p} %s: enter aEnvironment=%p\n", this, "GuestProcess::getEnvironment", aEnvironment));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironment);
        ArrayBSTROutConverter TmpEnvironment(ComSafeArrayOutArg(aEnvironment));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironment(TmpEnvironment.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironment.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironment=%zu hrc=%Rhrc\n", this, "GuestProcess::getEnvironment", !RT_VALID_PTR(aEnvironment) ? 0 : ComSafeArraySize(*aEnvironment), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestProcess::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestProcess::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(ExecutablePath)(BSTR *aExecutablePath)
{
    LogRelFlow(("{%p} %s: enter aExecutablePath=%p\n", this, "GuestProcess::getExecutablePath", aExecutablePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExecutablePath);
        BSTROutConverter TmpExecutablePath(aExecutablePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExecutablePath(TmpExecutablePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 0 /*normal*/,TmpExecutablePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExecutablePath=%ls hrc=%Rhrc\n", this, "GuestProcess::getExecutablePath", !RT_VALID_PTR(aExecutablePath) ? 0 : *aExecutablePath, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(ExitCode)(LONG *aExitCode)
{
    LogRelFlow(("{%p} %s: enter aExitCode=%p\n", this, "GuestProcess::getExitCode", aExitCode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExitCode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExitCode(aExitCode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 0 /*normal*/,*aExitCode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 1 /*hrc exception*/,*aExitCode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aExitCode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExitCode=%RI32 hrc=%Rhrc\n", this, "GuestProcess::getExitCode", !RT_VALID_PTR(aExitCode) ? 0 : *aExitCode, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestProcess::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestProcess::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(PID)(ULONG *aPID)
{
    LogRelFlow(("{%p} %s: enter aPID=%p\n", this, "GuestProcess::getPID", aPID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPID(aPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 1 /*hrc exception*/,*aPID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPID=%RU32 hrc=%Rhrc\n", this, "GuestProcess::getPID", !RT_VALID_PTR(aPID) ? 0 : *aPID, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Status)(ProcessStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestProcess::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestProcess::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute1IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute2IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute3IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute4IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute5IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute6IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute7IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute8IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestProcess properties
//

STDMETHODIMP GuestProcessWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestProcess::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestProcess::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IProcess methods
//

STDMETHODIMP GuestProcessWrap::WaitFor(ULONG aWaitFor,
                                       ULONG aTimeoutMS,
                                       ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%RU32 aTimeoutMS=%RU32 aReason=%p\n", this, "GuestProcess::waitFor", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_ENTER(this, aWaitFor, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitFor(aWaitFor,
                          aTimeoutMS,
                          aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 0 /*normal*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 1 /*hrc exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 9 /*unhandled exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestProcess::waitFor", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::WaitForArray(ComSafeArrayIn(ProcessWaitForFlag_T, aWaitFor),
                                            ULONG aTimeoutMS,
                                            ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%zu aTimeoutMS=%RU32 aReason=%p\n", this, "GuestProcess::waitForArray", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        ArrayInConverter<ProcessWaitForFlag_T> TmpWaitFor(ComSafeArrayInArg(aWaitFor));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_ENTER(this, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForArray(TmpWaitFor.array(),
                               aTimeoutMS,
                               aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestProcess::waitForArray", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Read(ULONG aHandle,
                                    ULONG aToRead,
                                    ULONG aTimeoutMS,
                                    ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aHandle=%RU32 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestProcess::read", aHandle, aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_ENTER(this, aHandle, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aHandle,
                       aToRead,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 0 /*normal*/, aHandle, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestProcess::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Write(ULONG aHandle,
                                     ULONG aFlags,
                                     ComSafeArrayIn(BYTE, aData),
                                     ULONG aTimeoutMS,
                                     ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aHandle=%RU32 aFlags=%RU32 aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestProcess::write", aHandle, aFlags, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_ENTER(this, aHandle, aFlags, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(aHandle,
                        aFlags,
                        TmpData.array(),
                        aTimeoutMS,
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 0 /*normal*/, aHandle, aFlags, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, aFlags, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aFlags, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestProcess::write", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::WriteArray(ULONG aHandle,
                                          ComSafeArrayIn(ProcessInputFlag_T, aFlags),
                                          ComSafeArrayIn(BYTE, aData),
                                          ULONG aTimeoutMS,
                                          ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aHandle=%RU32 aFlags=%zu aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestProcess::writeArray", aHandle, aFlags, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<ProcessInputFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_ENTER(this, aHandle, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = writeArray(aHandle,
                             TmpFlags.array(),
                             TmpData.array(),
                             aTimeoutMS,
                             aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 0 /*normal*/, aHandle, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, 0, 0, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, 0, 0, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestProcess::writeArray", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Terminate()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestProcess::terminate"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = terminate();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestProcess::terminate", hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod1IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod2IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod3IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod4IProcess()
{
    return E_NOTIMPL;
}

//
// IGuestProcess methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestProcessWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestProcessWrap, IGuestProcess, IProcess)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestProcessWrap.cpp"


// ##### BEGINFILE "GuestDirectoryWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDirectory.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTDIRECTORY

#include "GuestDirectoryWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDirectoryWrap)

//
// IDirectory properties
//

STDMETHODIMP GuestDirectoryWrap::COMGETTER(DirectoryName)(BSTR *aDirectoryName)
{
    LogRelFlow(("{%p} %s: enter aDirectoryName=%p\n", this, "GuestDirectory::getDirectoryName", aDirectoryName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectoryName);
        BSTROutConverter TmpDirectoryName(aDirectoryName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDirectoryName(TmpDirectoryName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 0 /*normal*/,TmpDirectoryName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectoryName=%ls hrc=%Rhrc\n", this, "GuestDirectory::getDirectoryName", !RT_VALID_PTR(aDirectoryName) ? 0 : *aDirectoryName, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestDirectory::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestDirectory::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(Filter)(BSTR *aFilter)
{
    LogRelFlow(("{%p} %s: enter aFilter=%p\n", this, "GuestDirectory::getFilter", aFilter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilter);
        BSTROutConverter TmpFilter(aFilter);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilter(TmpFilter.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 0 /*normal*/,TmpFilter.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilter=%ls hrc=%Rhrc\n", this, "GuestDirectory::getFilter", !RT_VALID_PTR(aFilter) ? 0 : *aFilter, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestDirectory::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,*aId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "GuestDirectory::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(Status)(DirectoryStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestDirectory::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestDirectory::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute1IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute2IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute3IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute4IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute5IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute6IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute7IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute8IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestDirectory properties
//

STDMETHODIMP GuestDirectoryWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestDirectory::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestDirectory::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IDirectory methods
//

STDMETHODIMP GuestDirectoryWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestDirectory::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDirectory::close", hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::List(ULONG aMaxEntries,
                                      ComSafeArrayOut(IFsObjInfo *, aObjInfo))
{
    LogRelFlow(("{%p} %s: enter aMaxEntries=%RU32 aObjInfo=%p\n", this, "GuestDirectory::list", aMaxEntries, aObjInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjInfo);


        
        ArrayComTypeOutConverter<IFsObjInfo> TmpObjInfo(ComSafeArrayOutArg(aObjInfo));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_LIST_ENTER(this, aMaxEntries);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = list(aMaxEntries,
                       TmpObjInfo.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_LIST_RETURN(this, hrc, 0 /*normal*/, aMaxEntries, (uint32_t)TmpObjInfo.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_LIST_RETURN(this, hrc, 1 /*hrc exception*/, aMaxEntries, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_LIST_RETURN(this, hrc, 9 /*unhandled exception*/, aMaxEntries, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%zu hrc=%Rhrc\n", this, "GuestDirectory::list", !RT_VALID_PTR(aObjInfo) ? 0 : ComSafeArraySize(*aObjInfo), hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::Read(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s: enter aObjInfo=%p\n", this, "GuestDirectory::read", aObjInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjInfo);


        ComTypeOutConverter<IFsObjInfo> TmpObjInfo(aObjInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "GuestDirectory::read", !RT_VALID_PTR(aObjInfo) ? 0 : *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::Rewind()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestDirectory::rewind"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_REWIND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = rewind();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_REWIND_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_REWIND_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_REWIND_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDirectory::rewind", hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod1IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod2IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod3IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod4IDirectory()
{
    return E_NOTIMPL;
}

//
// IGuestDirectory methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDirectoryWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestDirectoryWrap, IGuestDirectory, IDirectory)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDirectoryWrap.cpp"


// ##### BEGINFILE "GuestFileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTFILE

#include "GuestFileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFileWrap)

//
// IFile properties
//

STDMETHODIMP GuestFileWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestFile::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestFile::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestFile::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,*aId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "GuestFile::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InitialSize)(LONG64 *aInitialSize)
{
    LogRelFlow(("{%p} %s: enter aInitialSize=%p\n", this, "GuestFile::getInitialSize", aInitialSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInitialSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInitialSize(aInitialSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 0 /*normal*/,*aInitialSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aInitialSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInitialSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInitialSize=%RI64 hrc=%Rhrc\n", this, "GuestFile::getInitialSize", !RT_VALID_PTR(aInitialSize) ? 0 : *aInitialSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Offset)(LONG64 *aOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%p\n", this, "GuestFile::getOffset", aOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOffset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOffset(aOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 0 /*normal*/,*aOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 1 /*hrc exception*/,*aOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOffset=%RI64 hrc=%Rhrc\n", this, "GuestFile::getOffset", !RT_VALID_PTR(aOffset) ? 0 : *aOffset, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Status)(FileStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestFile::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestFile::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Filename)(BSTR *aFilename)
{
    LogRelFlow(("{%p} %s: enter aFilename=%p\n", this, "GuestFile::getFilename", aFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilename);
        BSTROutConverter TmpFilename(aFilename);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilename(TmpFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 0 /*normal*/,TmpFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilename=%ls hrc=%Rhrc\n", this, "GuestFile::getFilename", !RT_VALID_PTR(aFilename) ? 0 : *aFilename, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(CreationMode)(ULONG *aCreationMode)
{
    LogRelFlow(("{%p} %s: enter aCreationMode=%p\n", this, "GuestFile::getCreationMode", aCreationMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCreationMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCreationMode(aCreationMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 0 /*normal*/,*aCreationMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aCreationMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aCreationMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCreationMode=%RU32 hrc=%Rhrc\n", this, "GuestFile::getCreationMode", !RT_VALID_PTR(aCreationMode) ? 0 : *aCreationMode, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(OpenAction)(FileOpenAction_T *aOpenAction)
{
    LogRelFlow(("{%p} %s: enter aOpenAction=%p\n", this, "GuestFile::getOpenAction", aOpenAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOpenAction);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOpenAction(aOpenAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 0 /*normal*/,*aOpenAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 1 /*hrc exception*/,*aOpenAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aOpenAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOpenAction=%RU32 hrc=%Rhrc\n", this, "GuestFile::getOpenAction", !RT_VALID_PTR(aOpenAction) ? 0 : *aOpenAction, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(AccessMode)(FileAccessMode_T *aAccessMode)
{
    LogRelFlow(("{%p} %s: enter aAccessMode=%p\n", this, "GuestFile::getAccessMode", aAccessMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessMode(aAccessMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 0 /*normal*/,*aAccessMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessMode=%RU32 hrc=%Rhrc\n", this, "GuestFile::getAccessMode", !RT_VALID_PTR(aAccessMode) ? 0 : *aAccessMode, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute1IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute2IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute3IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute4IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute5IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute6IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute7IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute8IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestFile properties
//

STDMETHODIMP GuestFileWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestFile::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestFile::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IFile methods
//

STDMETHODIMP GuestFileWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestFile::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::close", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::QueryInfo(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s: enter aObjInfo=%p\n", this, "GuestFile::queryInfo", aObjInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjInfo);


        ComTypeOutConverter<IFsObjInfo> TmpObjInfo(aObjInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryInfo(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "GuestFile::queryInfo", !RT_VALID_PTR(aObjInfo) ? 0 : *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::QuerySize(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%p\n", this, "GuestFile::querySize", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSize);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 0 /*normal*/, *aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 1 /*hrc exception*/, *aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, *aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSize=%RI64 hrc=%Rhrc\n", this, "GuestFile::querySize", !RT_VALID_PTR(aSize) ? 0 : *aSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Read(ULONG aToRead,
                                 ULONG aTimeoutMS,
                                 ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestFile::read", aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_ENTER(this, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aToRead,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 0 /*normal*/, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 1 /*hrc exception*/, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestFile::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::ReadAt(LONG64 aOffset,
                                   ULONG aToRead,
                                   ULONG aTimeoutMS,
                                   ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestFile::readAt", aOffset, aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_ENTER(this, aOffset, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readAt(aOffset,
                         aToRead,
                         aTimeoutMS,
                         TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 0 /*normal*/, aOffset, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestFile::readAt", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Seek(LONG64 aOffset,
                                 FileSeekOrigin_T aWhence,
                                 LONG64 *aNewOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aWhence=%RU32 aNewOffset=%p\n", this, "GuestFile::seek", aOffset, aWhence, aNewOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNewOffset);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_ENTER(this, aOffset, aWhence);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = seek(aOffset,
                       aWhence,
                       aNewOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 0 /*normal*/, aOffset, aWhence, *aNewOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aWhence, *aNewOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aWhence, *aNewOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNewOffset=%RI64 hrc=%Rhrc\n", this, "GuestFile::seek", !RT_VALID_PTR(aNewOffset) ? 0 : *aNewOffset, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::SetACL(IN_BSTR aAcl,
                                   ULONG aMode)
{
    LogRelFlow(("{%p} %s: enter aAcl=%ls aMode=%RU32\n", this, "GuestFile::setACL", aAcl, aMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpAcl(aAcl);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_ENTER(this, TmpAcl.str().c_str(), aMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setACL(TmpAcl.str(),
                         aMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 0 /*normal*/, TmpAcl.str().c_str(), aMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::setACL", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::SetSize(LONG64 aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%RI64\n", this, "GuestFile::setSize", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_ENTER(this, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 0 /*normal*/, aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 1 /*hrc exception*/, aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::setSize", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Write(ComSafeArrayIn(BYTE, aData),
                                  ULONG aTimeoutMS,
                                  ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestFile::write", aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_ENTER(this, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(TmpData.array(),
                        aTimeoutMS,
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestFile::write", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::WriteAt(LONG64 aOffset,
                                    ComSafeArrayIn(BYTE, aData),
                                    ULONG aTimeoutMS,
                                    ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestFile::writeAt", aOffset, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_ENTER(this, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = writeAt(aOffset,
                          TmpData.array(),
                          aTimeoutMS,
                          aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 0 /*normal*/, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestFile::writeAt", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod1IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod2IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod3IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod4IFile()
{
    return E_NOTIMPL;
}

//
// IGuestFile methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestFileWrap, IGuestFile, IFile)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFileWrap.cpp"


// ##### BEGINFILE "FsObjInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFsObjInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_FSOBJINFO

#include "FsObjInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FsObjInfoWrap)

//
// IFsObjInfo properties
//

STDMETHODIMP FsObjInfoWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "FsObjInfo::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "FsObjInfo::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(Type)(FsObjType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "FsObjInfo::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(FileAttributes)(BSTR *aFileAttributes)
{
    LogRelFlow(("{%p} %s: enter aFileAttributes=%p\n", this, "FsObjInfo::getFileAttributes", aFileAttributes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFileAttributes);
        BSTROutConverter TmpFileAttributes(aFileAttributes);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_FILEATTRIBUTES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFileAttributes(TmpFileAttributes.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 0 /*normal*/,TmpFileAttributes.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFileAttributes=%ls hrc=%Rhrc\n", this, "FsObjInfo::getFileAttributes", !RT_VALID_PTR(aFileAttributes) ? 0 : *aFileAttributes, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(ObjectSize)(LONG64 *aObjectSize)
{
    LogRelFlow(("{%p} %s: enter aObjectSize=%p\n", this, "FsObjInfo::getObjectSize", aObjectSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjectSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_OBJECTSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getObjectSize(aObjectSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 0 /*normal*/,*aObjectSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aObjectSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aObjectSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aObjectSize=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getObjectSize", !RT_VALID_PTR(aObjectSize) ? 0 : *aObjectSize, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(AllocatedSize)(LONG64 *aAllocatedSize)
{
    LogRelFlow(("{%p} %s: enter aAllocatedSize=%p\n", this, "FsObjInfo::getAllocatedSize", aAllocatedSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllocatedSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ALLOCATEDSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllocatedSize(aAllocatedSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 0 /*normal*/,*aAllocatedSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aAllocatedSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllocatedSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllocatedSize=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getAllocatedSize", !RT_VALID_PTR(aAllocatedSize) ? 0 : *aAllocatedSize, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(AccessTime)(LONG64 *aAccessTime)
{
    LogRelFlow(("{%p} %s: enter aAccessTime=%p\n", this, "FsObjInfo::getAccessTime", aAccessTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ACCESSTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessTime(aAccessTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 0 /*normal*/,*aAccessTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessTime=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getAccessTime", !RT_VALID_PTR(aAccessTime) ? 0 : *aAccessTime, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(BirthTime)(LONG64 *aBirthTime)
{
    LogRelFlow(("{%p} %s: enter aBirthTime=%p\n", this, "FsObjInfo::getBirthTime", aBirthTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBirthTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_BIRTHTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBirthTime(aBirthTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 0 /*normal*/,*aBirthTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aBirthTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aBirthTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBirthTime=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getBirthTime", !RT_VALID_PTR(aBirthTime) ? 0 : *aBirthTime, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(ChangeTime)(LONG64 *aChangeTime)
{
    LogRelFlow(("{%p} %s: enter aChangeTime=%p\n", this, "FsObjInfo::getChangeTime", aChangeTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChangeTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_CHANGETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChangeTime(aChangeTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 0 /*normal*/,*aChangeTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aChangeTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aChangeTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChangeTime=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getChangeTime", !RT_VALID_PTR(aChangeTime) ? 0 : *aChangeTime, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(ModificationTime)(LONG64 *aModificationTime)
{
    LogRelFlow(("{%p} %s: enter aModificationTime=%p\n", this, "FsObjInfo::getModificationTime", aModificationTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aModificationTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_MODIFICATIONTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getModificationTime(aModificationTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 0 /*normal*/,*aModificationTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aModificationTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aModificationTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aModificationTime=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getModificationTime", !RT_VALID_PTR(aModificationTime) ? 0 : *aModificationTime, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(UID)(LONG *aUID)
{
    LogRelFlow(("{%p} %s: enter aUID=%p\n", this, "FsObjInfo::getUID", aUID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_UID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUID(aUID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_UID_RETURN(this, hrc, 0 /*normal*/,*aUID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_UID_RETURN(this, hrc, 1 /*hrc exception*/,*aUID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_UID_RETURN(this, hrc, 9 /*unhandled exception*/,*aUID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUID=%RI32 hrc=%Rhrc\n", this, "FsObjInfo::getUID", !RT_VALID_PTR(aUID) ? 0 : *aUID, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(UserName)(BSTR *aUserName)
{
    LogRelFlow(("{%p} %s: enter aUserName=%p\n", this, "FsObjInfo::getUserName", aUserName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserName);
        BSTROutConverter TmpUserName(aUserName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserName(TmpUserName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERNAME_RETURN(this, hrc, 0 /*normal*/,TmpUserName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserName=%ls hrc=%Rhrc\n", this, "FsObjInfo::getUserName", !RT_VALID_PTR(aUserName) ? 0 : *aUserName, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(GID)(LONG *aGID)
{
    LogRelFlow(("{%p} %s: enter aGID=%p\n", this, "FsObjInfo::getGID", aGID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGID(aGID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GID_RETURN(this, hrc, 0 /*normal*/,*aGID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GID_RETURN(this, hrc, 1 /*hrc exception*/,*aGID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGID=%RI32 hrc=%Rhrc\n", this, "FsObjInfo::getGID", !RT_VALID_PTR(aGID) ? 0 : *aGID, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(GroupName)(BSTR *aGroupName)
{
    LogRelFlow(("{%p} %s: enter aGroupName=%p\n", this, "FsObjInfo::getGroupName", aGroupName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroupName);
        BSTROutConverter TmpGroupName(aGroupName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GROUPNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGroupName(TmpGroupName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 0 /*normal*/,TmpGroupName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGroupName=%ls hrc=%Rhrc\n", this, "FsObjInfo::getGroupName", !RT_VALID_PTR(aGroupName) ? 0 : *aGroupName, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(NodeId)(LONG64 *aNodeId)
{
    LogRelFlow(("{%p} %s: enter aNodeId=%p\n", this, "FsObjInfo::getNodeId", aNodeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeId(aNodeId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEID_RETURN(this, hrc, 0 /*normal*/,*aNodeId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEID_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEID_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeId=%RI64 hrc=%Rhrc\n", this, "FsObjInfo::getNodeId", !RT_VALID_PTR(aNodeId) ? 0 : *aNodeId, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(NodeIdDevice)(ULONG *aNodeIdDevice)
{
    LogRelFlow(("{%p} %s: enter aNodeIdDevice=%p\n", this, "FsObjInfo::getNodeIdDevice", aNodeIdDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeIdDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEIDDEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeIdDevice(aNodeIdDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 0 /*normal*/,*aNodeIdDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeIdDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeIdDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeIdDevice=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getNodeIdDevice", !RT_VALID_PTR(aNodeIdDevice) ? 0 : *aNodeIdDevice, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(HardLinks)(ULONG *aHardLinks)
{
    LogRelFlow(("{%p} %s: enter aHardLinks=%p\n", this, "FsObjInfo::getHardLinks", aHardLinks));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardLinks);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_HARDLINKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardLinks(aHardLinks);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 0 /*normal*/,*aHardLinks);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 1 /*hrc exception*/,*aHardLinks);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 9 /*unhandled exception*/,*aHardLinks);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardLinks=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getHardLinks", !RT_VALID_PTR(aHardLinks) ? 0 : *aHardLinks, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(DeviceNumber)(ULONG *aDeviceNumber)
{
    LogRelFlow(("{%p} %s: enter aDeviceNumber=%p\n", this, "FsObjInfo::getDeviceNumber", aDeviceNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceNumber);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_DEVICENUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceNumber(aDeviceNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 0 /*normal*/,*aDeviceNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aDeviceNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDeviceNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceNumber=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getDeviceNumber", !RT_VALID_PTR(aDeviceNumber) ? 0 : *aDeviceNumber, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(GenerationId)(ULONG *aGenerationId)
{
    LogRelFlow(("{%p} %s: enter aGenerationId=%p\n", this, "FsObjInfo::getGenerationId", aGenerationId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGenerationId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GENERATIONID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGenerationId(aGenerationId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 0 /*normal*/,*aGenerationId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 1 /*hrc exception*/,*aGenerationId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGenerationId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGenerationId=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getGenerationId", !RT_VALID_PTR(aGenerationId) ? 0 : *aGenerationId, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(UserFlags)(ULONG *aUserFlags)
{
    LogRelFlow(("{%p} %s: enter aUserFlags=%p\n", this, "FsObjInfo::getUserFlags", aUserFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserFlags);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERFLAGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserFlags(aUserFlags);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 0 /*normal*/,*aUserFlags);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 1 /*hrc exception*/,*aUserFlags);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/,*aUserFlags);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserFlags=%RU32 hrc=%Rhrc\n", this, "FsObjInfo::getUserFlags", !RT_VALID_PTR(aUserFlags) ? 0 : *aUserFlags, hrc));
    return hrc;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute1IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute2IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute3IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute4IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute5IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute6IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute7IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsObjInfoWrap::COMGETTER(InternalAndReservedAttribute8IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFsObjInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FsObjInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FsObjInfoWrap, IFsObjInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FsObjInfoWrap.cpp"


// ##### BEGINFILE "GuestFsObjInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFsObjInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTFSOBJINFO

#include "GuestFsObjInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFsObjInfoWrap)

//
// IFsObjInfo properties
//

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestFsObjInfo::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(Type)(FsObjType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestFsObjInfo::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(FileAttributes)(BSTR *aFileAttributes)
{
    LogRelFlow(("{%p} %s: enter aFileAttributes=%p\n", this, "GuestFsObjInfo::getFileAttributes", aFileAttributes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFileAttributes);
        BSTROutConverter TmpFileAttributes(aFileAttributes);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFileAttributes(TmpFileAttributes.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 0 /*normal*/,TmpFileAttributes.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFileAttributes=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getFileAttributes", !RT_VALID_PTR(aFileAttributes) ? 0 : *aFileAttributes, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ObjectSize)(LONG64 *aObjectSize)
{
    LogRelFlow(("{%p} %s: enter aObjectSize=%p\n", this, "GuestFsObjInfo::getObjectSize", aObjectSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjectSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getObjectSize(aObjectSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 0 /*normal*/,*aObjectSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aObjectSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aObjectSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aObjectSize=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getObjectSize", !RT_VALID_PTR(aObjectSize) ? 0 : *aObjectSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(AllocatedSize)(LONG64 *aAllocatedSize)
{
    LogRelFlow(("{%p} %s: enter aAllocatedSize=%p\n", this, "GuestFsObjInfo::getAllocatedSize", aAllocatedSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllocatedSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllocatedSize(aAllocatedSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 0 /*normal*/,*aAllocatedSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aAllocatedSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllocatedSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllocatedSize=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getAllocatedSize", !RT_VALID_PTR(aAllocatedSize) ? 0 : *aAllocatedSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(AccessTime)(LONG64 *aAccessTime)
{
    LogRelFlow(("{%p} %s: enter aAccessTime=%p\n", this, "GuestFsObjInfo::getAccessTime", aAccessTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessTime(aAccessTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 0 /*normal*/,*aAccessTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getAccessTime", !RT_VALID_PTR(aAccessTime) ? 0 : *aAccessTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(BirthTime)(LONG64 *aBirthTime)
{
    LogRelFlow(("{%p} %s: enter aBirthTime=%p\n", this, "GuestFsObjInfo::getBirthTime", aBirthTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBirthTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBirthTime(aBirthTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 0 /*normal*/,*aBirthTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aBirthTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aBirthTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBirthTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getBirthTime", !RT_VALID_PTR(aBirthTime) ? 0 : *aBirthTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ChangeTime)(LONG64 *aChangeTime)
{
    LogRelFlow(("{%p} %s: enter aChangeTime=%p\n", this, "GuestFsObjInfo::getChangeTime", aChangeTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChangeTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChangeTime(aChangeTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 0 /*normal*/,*aChangeTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aChangeTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aChangeTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChangeTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getChangeTime", !RT_VALID_PTR(aChangeTime) ? 0 : *aChangeTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ModificationTime)(LONG64 *aModificationTime)
{
    LogRelFlow(("{%p} %s: enter aModificationTime=%p\n", this, "GuestFsObjInfo::getModificationTime", aModificationTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aModificationTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getModificationTime(aModificationTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 0 /*normal*/,*aModificationTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aModificationTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aModificationTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aModificationTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getModificationTime", !RT_VALID_PTR(aModificationTime) ? 0 : *aModificationTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UID)(LONG *aUID)
{
    LogRelFlow(("{%p} %s: enter aUID=%p\n", this, "GuestFsObjInfo::getUID", aUID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUID(aUID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 0 /*normal*/,*aUID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 1 /*hrc exception*/,*aUID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 9 /*unhandled exception*/,*aUID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUID=%RI32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getUID", !RT_VALID_PTR(aUID) ? 0 : *aUID, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UserName)(BSTR *aUserName)
{
    LogRelFlow(("{%p} %s: enter aUserName=%p\n", this, "GuestFsObjInfo::getUserName", aUserName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserName);
        BSTROutConverter TmpUserName(aUserName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserName(TmpUserName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 0 /*normal*/,TmpUserName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getUserName", !RT_VALID_PTR(aUserName) ? 0 : *aUserName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GID)(LONG *aGID)
{
    LogRelFlow(("{%p} %s: enter aGID=%p\n", this, "GuestFsObjInfo::getGID", aGID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGID(aGID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 0 /*normal*/,*aGID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 1 /*hrc exception*/,*aGID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGID=%RI32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getGID", !RT_VALID_PTR(aGID) ? 0 : *aGID, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GroupName)(BSTR *aGroupName)
{
    LogRelFlow(("{%p} %s: enter aGroupName=%p\n", this, "GuestFsObjInfo::getGroupName", aGroupName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroupName);
        BSTROutConverter TmpGroupName(aGroupName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGroupName(TmpGroupName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 0 /*normal*/,TmpGroupName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGroupName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getGroupName", !RT_VALID_PTR(aGroupName) ? 0 : *aGroupName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(NodeId)(LONG64 *aNodeId)
{
    LogRelFlow(("{%p} %s: enter aNodeId=%p\n", this, "GuestFsObjInfo::getNodeId", aNodeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeId(aNodeId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 0 /*normal*/,*aNodeId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeId=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getNodeId", !RT_VALID_PTR(aNodeId) ? 0 : *aNodeId, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(NodeIdDevice)(ULONG *aNodeIdDevice)
{
    LogRelFlow(("{%p} %s: enter aNodeIdDevice=%p\n", this, "GuestFsObjInfo::getNodeIdDevice", aNodeIdDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeIdDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeIdDevice(aNodeIdDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 0 /*normal*/,*aNodeIdDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeIdDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeIdDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeIdDevice=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getNodeIdDevice", !RT_VALID_PTR(aNodeIdDevice) ? 0 : *aNodeIdDevice, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(HardLinks)(ULONG *aHardLinks)
{
    LogRelFlow(("{%p} %s: enter aHardLinks=%p\n", this, "GuestFsObjInfo::getHardLinks", aHardLinks));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardLinks);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardLinks(aHardLinks);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 0 /*normal*/,*aHardLinks);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 1 /*hrc exception*/,*aHardLinks);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 9 /*unhandled exception*/,*aHardLinks);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardLinks=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getHardLinks", !RT_VALID_PTR(aHardLinks) ? 0 : *aHardLinks, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(DeviceNumber)(ULONG *aDeviceNumber)
{
    LogRelFlow(("{%p} %s: enter aDeviceNumber=%p\n", this, "GuestFsObjInfo::getDeviceNumber", aDeviceNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceNumber);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceNumber(aDeviceNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 0 /*normal*/,*aDeviceNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aDeviceNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDeviceNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceNumber=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getDeviceNumber", !RT_VALID_PTR(aDeviceNumber) ? 0 : *aDeviceNumber, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GenerationId)(ULONG *aGenerationId)
{
    LogRelFlow(("{%p} %s: enter aGenerationId=%p\n", this, "GuestFsObjInfo::getGenerationId", aGenerationId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGenerationId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGenerationId(aGenerationId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 0 /*normal*/,*aGenerationId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 1 /*hrc exception*/,*aGenerationId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGenerationId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGenerationId=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getGenerationId", !RT_VALID_PTR(aGenerationId) ? 0 : *aGenerationId, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UserFlags)(ULONG *aUserFlags)
{
    LogRelFlow(("{%p} %s: enter aUserFlags=%p\n", this, "GuestFsObjInfo::getUserFlags", aUserFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserFlags);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserFlags(aUserFlags);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 0 /*normal*/,*aUserFlags);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 1 /*hrc exception*/,*aUserFlags);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/,*aUserFlags);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserFlags=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getUserFlags", !RT_VALID_PTR(aUserFlags) ? 0 : *aUserFlags, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute1IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute2IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute3IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute4IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute5IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute6IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute7IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute8IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestFsObjInfo properties
//

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestFsObjInfo::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestFsObjInfo::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IFsObjInfo methods
//

//
// IGuestFsObjInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFsObjInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestFsObjInfoWrap, IGuestFsObjInfo, IFsObjInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFsObjInfoWrap.cpp"


// ##### BEGINFILE "ProgressWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IProgress.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PROGRESS

#include "ProgressWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ProgressWrap)

//
// IProgress properties
//

STDMETHODIMP ProgressWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Progress::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Progress::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Progress::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Progress::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Initiator)(IUnknown **aInitiator)
{
    LogRelFlow(("{%p} %s: enter aInitiator=%p\n", this, "Progress::getInitiator", aInitiator));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInitiator);
        ComTypeOutConverter<IUnknown> TmpInitiator(aInitiator);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInitiator(TmpInitiator.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 0 /*normal*/,(void *)TmpInitiator.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInitiator=%p hrc=%Rhrc\n", this, "Progress::getInitiator", !RT_VALID_PTR(aInitiator) ? 0 : *aInitiator, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Cancelable)(BOOL *aCancelable)
{
    LogRelFlow(("{%p} %s: enter aCancelable=%p\n", this, "Progress::getCancelable", aCancelable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCancelable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCancelable(aCancelable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 0 /*normal*/,*aCancelable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aCancelable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aCancelable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCancelable=%RTbool hrc=%Rhrc\n", this, "Progress::getCancelable", !RT_VALID_PTR(aCancelable) ? 0 : *aCancelable, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Percent)(ULONG *aPercent)
{
    LogRelFlow(("{%p} %s: enter aPercent=%p\n", this, "Progress::getPercent", aPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPercent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPercent(aPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 0 /*normal*/,*aPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 1 /*hrc exception*/,*aPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPercent=%RU32 hrc=%Rhrc\n", this, "Progress::getPercent", !RT_VALID_PTR(aPercent) ? 0 : *aPercent, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(TimeRemaining)(LONG *aTimeRemaining)
{
    LogRelFlow(("{%p} %s: enter aTimeRemaining=%p\n", this, "Progress::getTimeRemaining", aTimeRemaining));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeRemaining);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeRemaining(aTimeRemaining);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 0 /*normal*/,*aTimeRemaining);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeRemaining);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeRemaining);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeRemaining=%RI32 hrc=%Rhrc\n", this, "Progress::getTimeRemaining", !RT_VALID_PTR(aTimeRemaining) ? 0 : *aTimeRemaining, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Completed)(BOOL *aCompleted)
{
    LogRelFlow(("{%p} %s: enter aCompleted=%p\n", this, "Progress::getCompleted", aCompleted));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCompleted);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCompleted(aCompleted);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 0 /*normal*/,*aCompleted != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 1 /*hrc exception*/,*aCompleted != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCompleted != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCompleted=%RTbool hrc=%Rhrc\n", this, "Progress::getCompleted", !RT_VALID_PTR(aCompleted) ? 0 : *aCompleted, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Canceled)(BOOL *aCanceled)
{
    LogRelFlow(("{%p} %s: enter aCanceled=%p\n", this, "Progress::getCanceled", aCanceled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCanceled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCanceled(aCanceled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 0 /*normal*/,*aCanceled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 1 /*hrc exception*/,*aCanceled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCanceled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCanceled=%RTbool hrc=%Rhrc\n", this, "Progress::getCanceled", !RT_VALID_PTR(aCanceled) ? 0 : *aCanceled, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(ResultCode)(LONG *aResultCode)
{
    LogRelFlow(("{%p} %s: enter aResultCode=%p\n", this, "Progress::getResultCode", aResultCode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultCode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getResultCode(aResultCode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 0 /*normal*/,*aResultCode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 1 /*hrc exception*/,*aResultCode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aResultCode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aResultCode=%RI32 hrc=%Rhrc\n", this, "Progress::getResultCode", !RT_VALID_PTR(aResultCode) ? 0 : *aResultCode, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(ErrorInfo)(IVirtualBoxErrorInfo **aErrorInfo)
{
    LogRelFlow(("{%p} %s: enter aErrorInfo=%p\n", this, "Progress::getErrorInfo", aErrorInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aErrorInfo);
        ComTypeOutConverter<IVirtualBoxErrorInfo> TmpErrorInfo(aErrorInfo);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getErrorInfo(TmpErrorInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 0 /*normal*/,(void *)TmpErrorInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aErrorInfo=%p hrc=%Rhrc\n", this, "Progress::getErrorInfo", !RT_VALID_PTR(aErrorInfo) ? 0 : *aErrorInfo, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationCount)(ULONG *aOperationCount)
{
    LogRelFlow(("{%p} %s: enter aOperationCount=%p\n", this, "Progress::getOperationCount", aOperationCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationCount(aOperationCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 0 /*normal*/,*aOperationCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationCount=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationCount", !RT_VALID_PTR(aOperationCount) ? 0 : *aOperationCount, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Operation)(ULONG *aOperation)
{
    LogRelFlow(("{%p} %s: enter aOperation=%p\n", this, "Progress::getOperation", aOperation));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperation);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperation(aOperation);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 0 /*normal*/,*aOperation);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aOperation);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperation);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperation=%RU32 hrc=%Rhrc\n", this, "Progress::getOperation", !RT_VALID_PTR(aOperation) ? 0 : *aOperation, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationDescription)(BSTR *aOperationDescription)
{
    LogRelFlow(("{%p} %s: enter aOperationDescription=%p\n", this, "Progress::getOperationDescription", aOperationDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationDescription);
        BSTROutConverter TmpOperationDescription(aOperationDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationDescription(TmpOperationDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpOperationDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationDescription=%ls hrc=%Rhrc\n", this, "Progress::getOperationDescription", !RT_VALID_PTR(aOperationDescription) ? 0 : *aOperationDescription, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationPercent)(ULONG *aOperationPercent)
{
    LogRelFlow(("{%p} %s: enter aOperationPercent=%p\n", this, "Progress::getOperationPercent", aOperationPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationPercent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationPercent(aOperationPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 0 /*normal*/,*aOperationPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationPercent=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationPercent", !RT_VALID_PTR(aOperationPercent) ? 0 : *aOperationPercent, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationWeight)(ULONG *aOperationWeight)
{
    LogRelFlow(("{%p} %s: enter aOperationWeight=%p\n", this, "Progress::getOperationWeight", aOperationWeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationWeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationWeight(aOperationWeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 0 /*normal*/,*aOperationWeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationWeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationWeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationWeight=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationWeight", !RT_VALID_PTR(aOperationWeight) ? 0 : *aOperationWeight, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Timeout)(ULONG *aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%p\n", this, "Progress::getTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeout=%RU32 hrc=%Rhrc\n", this, "Progress::getTimeout", !RT_VALID_PTR(aTimeout) ? 0 : *aTimeout, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMSETTER(Timeout)(ULONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RU32\n", this, "Progress::setTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setTimeout", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Progress::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Progress::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute1IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute2IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute3IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute4IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute5IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute6IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute7IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute8IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute9IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute10IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute11IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute12IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IInternalProgressControl properties
//

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute1IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute2IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute3IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute4IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute5IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute6IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute7IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute8IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IProgress methods
//

STDMETHODIMP ProgressWrap::WaitForCompletion(LONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32\n", this, "Progress::waitForCompletion", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForCompletion(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 0 /*normal*/, aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::WaitForOperationCompletion(ULONG aOperation,
                                                      LONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aOperation=%RU32 aTimeout=%RI32\n", this, "Progress::waitForOperationCompletion", aOperation, aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_ENTER(this, aOperation, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForOperationCompletion(aOperation,
                                             aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 0 /*normal*/, aOperation, aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, aOperation, aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, aOperation, aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForOperationCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::Cancel()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Progress::cancel"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancel();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::cancel", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod1IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod2IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod3IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod4IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod5IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod6IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod7IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod8IProgress()
{
    return E_NOTIMPL;
}

//
// IInternalProgressControl methods
//

STDMETHODIMP ProgressWrap::SetCurrentOperationProgress(ULONG aPercent)
{
    LogRelFlow(("{%p} %s: enter aPercent=%RU32\n", this, "Progress::setCurrentOperationProgress", aPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_ENTER(this, aPercent);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCurrentOperationProgress(aPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 0 /*normal*/, aPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 1 /*hrc exception*/, aPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 9 /*unhandled exception*/, aPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setCurrentOperationProgress", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::WaitForOtherProgressCompletion(IProgress *aProgressOther,
                                                          ULONG aTimeoutMS)
{
    LogRelFlow(("{%p} %s: enter aProgressOther=%p aTimeoutMS=%RU32\n", this, "Progress::waitForOtherProgressCompletion", aProgressOther, aTimeoutMS));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IProgress> TmpProgressOther(aProgressOther);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_ENTER(this, (void *)TmpProgressOther.ptr(), aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForOtherProgressCompletion(TmpProgressOther.ptr(),
                                                 aTimeoutMS);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgressOther.ptr(), aTimeoutMS);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, 0, aTimeoutMS);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aTimeoutMS);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForOtherProgressCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::SetNextOperation(IN_BSTR aNextOperationDescription,
                                            ULONG aNextOperationsWeight)
{
    LogRelFlow(("{%p} %s: enter aNextOperationDescription=%ls aNextOperationsWeight=%RU32\n", this, "Progress::setNextOperation", aNextOperationDescription, aNextOperationsWeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpNextOperationDescription(aNextOperationDescription);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_ENTER(this, TmpNextOperationDescription.str().c_str(), aNextOperationsWeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNextOperation(TmpNextOperationDescription.str(),
                                   aNextOperationsWeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 0 /*normal*/, TmpNextOperationDescription.str().c_str(), aNextOperationsWeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 1 /*hrc exception*/, 0, aNextOperationsWeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aNextOperationsWeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setNextOperation", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::NotifyPointOfNoReturn()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Progress::notifyPointOfNoReturn"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyPointOfNoReturn();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::notifyPointOfNoReturn", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::NotifyComplete(LONG aResultCode,
                                          IVirtualBoxErrorInfo *aErrorInfo)
{
    LogRelFlow(("{%p} %s: enter aResultCode=%RI32 aErrorInfo=%p\n", this, "Progress::notifyComplete", aResultCode, aErrorInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpErrorInfo(aErrorInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_ENTER(this, aResultCode, (void *)TmpErrorInfo.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyComplete(aResultCode,
                                 TmpErrorInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 0 /*normal*/, aResultCode, (void *)TmpErrorInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 1 /*hrc exception*/, aResultCode, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 9 /*unhandled exception*/, aResultCode, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::notifyComplete", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod1IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod2IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod3IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod4IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod5IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod6IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod7IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod8IInternalProgressControl()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ProgressWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ProgressWrap, IProgress, IInternalProgressControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ProgressWrap.cpp"


// ##### BEGINFILE "SnapshotWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISnapshot.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_SNAPSHOT

#include "SnapshotWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SnapshotWrap)

//
// ISnapshot properties
//

STDMETHODIMP SnapshotWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Snapshot::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Snapshot::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Snapshot::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Snapshot::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Snapshot::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Snapshot::setName", hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Snapshot::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Snapshot::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMSETTER(Description)(IN_BSTR aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%ls\n", this, "Snapshot::setDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_ENTER(this, TmpDescription.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Snapshot::setDescription", hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(TimeStamp)(LONG64 *aTimeStamp)
{
    LogRelFlow(("{%p} %s: enter aTimeStamp=%p\n", this, "Snapshot::getTimeStamp", aTimeStamp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeStamp);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeStamp(aTimeStamp);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 0 /*normal*/,*aTimeStamp);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeStamp);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeStamp);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeStamp=%RI64 hrc=%Rhrc\n", this, "Snapshot::getTimeStamp", !RT_VALID_PTR(aTimeStamp) ? 0 : *aTimeStamp, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Online)(BOOL *aOnline)
{
    LogRelFlow(("{%p} %s: enter aOnline=%p\n", this, "Snapshot::getOnline", aOnline));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOnline);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOnline(aOnline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 0 /*normal*/,*aOnline != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 1 /*hrc exception*/,*aOnline != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aOnline != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOnline=%RTbool hrc=%Rhrc\n", this, "Snapshot::getOnline", !RT_VALID_PTR(aOnline) ? 0 : *aOnline, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Snapshot::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "Snapshot::getMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Parent)(ISnapshot **aParent)
{
    LogRelFlow(("{%p} %s: enter aParent=%p\n", this, "Snapshot::getParent", aParent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParent);
        ComTypeOutConverter<ISnapshot> TmpParent(aParent);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParent(TmpParent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpParent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParent=%p hrc=%Rhrc\n", this, "Snapshot::getParent", !RT_VALID_PTR(aParent) ? 0 : *aParent, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Children)(ComSafeArrayOut(ISnapshot *, aChildren))
{
    LogRelFlow(("{%p} %s: enter aChildren=%p\n", this, "Snapshot::getChildren", aChildren));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChildren);
        ArrayComTypeOutConverter<ISnapshot> TmpChildren(ComSafeArrayOutArg(aChildren));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChildren(TmpChildren.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpChildren.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChildren=%zu hrc=%Rhrc\n", this, "Snapshot::getChildren", !RT_VALID_PTR(aChildren) ? 0 : ComSafeArraySize(*aChildren), hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(ChildrenCount)(ULONG *aChildrenCount)
{
    LogRelFlow(("{%p} %s: enter aChildrenCount=%p\n", this, "Snapshot::getChildrenCount", aChildrenCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChildrenCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChildrenCount(aChildrenCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 0 /*normal*/,*aChildrenCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aChildrenCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aChildrenCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChildrenCount=%RU32 hrc=%Rhrc\n", this, "Snapshot::getChildrenCount", !RT_VALID_PTR(aChildrenCount) ? 0 : *aChildrenCount, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute1ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute2ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute3ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute4ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute5ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute6ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute7ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute8ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISnapshot methods
//

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod1ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod2ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod3ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod4ISnapshot()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SnapshotWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotWrap, ISnapshot)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SnapshotWrap.cpp"


// ##### BEGINFILE "MediumAttachmentWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMediumAttachment.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMATTACHMENT

#include "MediumAttachmentWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumAttachmentWrap)

//
// IMediumAttachment properties
//

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "MediumAttachment::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "MediumAttachment::getMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Medium)(IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aMedium=%p\n", this, "MediumAttachment::getMedium", aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMedium(TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMedium=%p hrc=%Rhrc\n", this, "MediumAttachment::getMedium", !RT_VALID_PTR(aMedium) ? 0 : *aMedium, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Controller)(BSTR *aController)
{
    LogRelFlow(("{%p} %s: enter aController=%p\n", this, "MediumAttachment::getController", aController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aController);
        BSTROutConverter TmpController(aController);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getController(TmpController.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 0 /*normal*/,TmpController.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aController=%ls hrc=%Rhrc\n", this, "MediumAttachment::getController", !RT_VALID_PTR(aController) ? 0 : *aController, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Port)(LONG *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "MediumAttachment::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(aPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 0 /*normal*/,*aPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,*aPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%RI32 hrc=%Rhrc\n", this, "MediumAttachment::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Device)(LONG *aDevice)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p\n", this, "MediumAttachment::getDevice", aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDevice(aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 0 /*normal*/,*aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDevice=%RI32 hrc=%Rhrc\n", this, "MediumAttachment::getDevice", !RT_VALID_PTR(aDevice) ? 0 : *aDevice, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Type)(DeviceType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "MediumAttachment::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "MediumAttachment::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Passthrough)(BOOL *aPassthrough)
{
    LogRelFlow(("{%p} %s: enter aPassthrough=%p\n", this, "MediumAttachment::getPassthrough", aPassthrough));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPassthrough);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPassthrough(aPassthrough);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 0 /*normal*/,*aPassthrough != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 1 /*hrc exception*/,*aPassthrough != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 9 /*unhandled exception*/,*aPassthrough != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPassthrough=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getPassthrough", !RT_VALID_PTR(aPassthrough) ? 0 : *aPassthrough, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(TemporaryEject)(BOOL *aTemporaryEject)
{
    LogRelFlow(("{%p} %s: enter aTemporaryEject=%p\n", this, "MediumAttachment::getTemporaryEject", aTemporaryEject));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTemporaryEject);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTemporaryEject(aTemporaryEject);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 0 /*normal*/,*aTemporaryEject != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 1 /*hrc exception*/,*aTemporaryEject != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTemporaryEject != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTemporaryEject=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getTemporaryEject", !RT_VALID_PTR(aTemporaryEject) ? 0 : *aTemporaryEject, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(IsEjected)(BOOL *aIsEjected)
{
    LogRelFlow(("{%p} %s: enter aIsEjected=%p\n", this, "MediumAttachment::getIsEjected", aIsEjected));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsEjected);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsEjected(aIsEjected);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 0 /*normal*/,*aIsEjected != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 1 /*hrc exception*/,*aIsEjected != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsEjected != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsEjected=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getIsEjected", !RT_VALID_PTR(aIsEjected) ? 0 : *aIsEjected, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(NonRotational)(BOOL *aNonRotational)
{
    LogRelFlow(("{%p} %s: enter aNonRotational=%p\n", this, "MediumAttachment::getNonRotational", aNonRotational));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNonRotational);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNonRotational(aNonRotational);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 0 /*normal*/,*aNonRotational != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 1 /*hrc exception*/,*aNonRotational != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 9 /*unhandled exception*/,*aNonRotational != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNonRotational=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getNonRotational", !RT_VALID_PTR(aNonRotational) ? 0 : *aNonRotational, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Discard)(BOOL *aDiscard)
{
    LogRelFlow(("{%p} %s: enter aDiscard=%p\n", this, "MediumAttachment::getDiscard", aDiscard));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDiscard);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDiscard(aDiscard);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 0 /*normal*/,*aDiscard != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 1 /*hrc exception*/,*aDiscard != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 9 /*unhandled exception*/,*aDiscard != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDiscard=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getDiscard", !RT_VALID_PTR(aDiscard) ? 0 : *aDiscard, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(HotPluggable)(BOOL *aHotPluggable)
{
    LogRelFlow(("{%p} %s: enter aHotPluggable=%p\n", this, "MediumAttachment::getHotPluggable", aHotPluggable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotPluggable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotPluggable(aHotPluggable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 0 /*normal*/,*aHotPluggable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aHotPluggable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotPluggable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotPluggable=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getHotPluggable", !RT_VALID_PTR(aHotPluggable) ? 0 : *aHotPluggable, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(BandwidthGroup)(IBandwidthGroup **aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroup=%p\n", this, "MediumAttachment::getBandwidthGroup", aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroup);
        ComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBandwidthGroup(TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBandwidthGroup=%p hrc=%Rhrc\n", this, "MediumAttachment::getBandwidthGroup", !RT_VALID_PTR(aBandwidthGroup) ? 0 : *aBandwidthGroup, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute1IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute2IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute3IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute4IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute5IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute6IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute7IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute8IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMediumAttachment methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumAttachmentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumAttachmentWrap, IMediumAttachment)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumAttachmentWrap.cpp"


// ##### BEGINFILE "DataStreamWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDataStream.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DATASTREAM

#include "DataStreamWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DataStreamWrap)

//
// IDataStream properties
//

STDMETHODIMP DataStreamWrap::COMGETTER(ReadSize)(ULONG *aReadSize)
{
    LogRelFlow(("{%p} %s: enter aReadSize=%p\n", this, "DataStream::getReadSize", aReadSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReadSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReadSize(aReadSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 0 /*normal*/,*aReadSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aReadSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aReadSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReadSize=%RU32 hrc=%Rhrc\n", this, "DataStream::getReadSize", !RT_VALID_PTR(aReadSize) ? 0 : *aReadSize, hrc));
    return hrc;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute1IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute2IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute3IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute4IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute5IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute6IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute7IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute8IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDataStream methods
//

STDMETHODIMP DataStreamWrap::Read(ULONG aSize,
                                  ULONG aTimeoutMS,
                                  ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aSize=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "DataStream::read", aSize, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_ENTER(this, aSize, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aSize,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 0 /*normal*/, aSize, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 1 /*hrc exception*/, aSize, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aSize, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "DataStream::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod1IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod2IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod3IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod4IDataStream()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DataStreamWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DataStreamWrap, IDataStream)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DataStreamWrap.cpp"


// ##### BEGINFILE "MediumIOWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMediumIO.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMIO

#include "MediumIOWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumIOWrap)

//
// IMediumIO properties
//

STDMETHODIMP MediumIOWrap::COMGETTER(Medium)(IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aMedium=%p\n", this, "MediumIO::getMedium", aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMedium(TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMedium=%p hrc=%Rhrc\n", this, "MediumIO::getMedium", !RT_VALID_PTR(aMedium) ? 0 : *aMedium, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(Writable)(BOOL *aWritable)
{
    LogRelFlow(("{%p} %s: enter aWritable=%p\n", this, "MediumIO::getWritable", aWritable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWritable(aWritable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 0 /*normal*/,*aWritable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWritable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWritable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWritable=%RTbool hrc=%Rhrc\n", this, "MediumIO::getWritable", !RT_VALID_PTR(aWritable) ? 0 : *aWritable, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(Explorer)(IVFSExplorer **aExplorer)
{
    LogRelFlow(("{%p} %s: enter aExplorer=%p\n", this, "MediumIO::getExplorer", aExplorer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExplorer);
        ComTypeOutConverter<IVFSExplorer> TmpExplorer(aExplorer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExplorer(TmpExplorer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpExplorer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExplorer=%p hrc=%Rhrc\n", this, "MediumIO::getExplorer", !RT_VALID_PTR(aExplorer) ? 0 : *aExplorer, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute1IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute2IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute3IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute4IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute5IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute6IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute7IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute8IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMediumIO methods
//

STDMETHODIMP MediumIOWrap::Read(LONG64 aOffset,
                                ULONG aSize,
                                ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aSize=%RU32 aData=%p\n", this, "MediumIO::read", aOffset, aSize, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_ENTER(this, aOffset, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aOffset,
                       aSize,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 0 /*normal*/, aOffset, aSize, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "MediumIO::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::Write(LONG64 aOffset,
                                 ComSafeArrayIn(BYTE, aData),
                                 ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aData=%zu aWritten=%p\n", this, "MediumIO::write", aOffset, aData, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_ENTER(this, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(aOffset,
                        TmpData.array(),
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 0 /*normal*/, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, 0, 0, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, 0, 0, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "MediumIO::write", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::FormatFAT(BOOL aQuick)
{
    LogRelFlow(("{%p} %s: enter aQuick=%RTbool\n", this, "MediumIO::formatFAT", aQuick));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_ENTER(this, aQuick != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = formatFAT(aQuick != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 0 /*normal*/, aQuick != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 1 /*hrc exception*/, aQuick != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 9 /*unhandled exception*/, aQuick != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::formatFAT", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::InitializePartitionTable(PartitionTableType_T aFormat,
                                                    BOOL aWholeDiskInOneEntry)
{
    LogRelFlow(("{%p} %s: enter aFormat=%RU32 aWholeDiskInOneEntry=%RTbool\n", this, "MediumIO::initializePartitionTable", aFormat, aWholeDiskInOneEntry));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_ENTER(this, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = initializePartitionTable(aFormat,
                                           aWholeDiskInOneEntry != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 0 /*normal*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 1 /*hrc exception*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 9 /*unhandled exception*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::initializePartitionTable", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::ConvertToStream(IN_BSTR aFormat,
                                           ComSafeArrayIn(MediumVariant_T, aVariant),
                                           ULONG aBufferSize,
                                           IDataStream **aStream,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aVariant=%zu aBufferSize=%RU32 aStream=%p aProgress=%p\n", this, "MediumIO::convertToStream", aFormat, aVariant, aBufferSize, aStream, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStream);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFormat(aFormat);
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        
        ComTypeOutConverter<IDataStream> TmpStream(aStream);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_ENTER(this, TmpFormat.str().c_str(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, aBufferSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = convertToStream(TmpFormat.str(),
                                  TmpVariant.array(),
                                  aBufferSize,
                                  TmpStream.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, aBufferSize, (void *)TmpStream.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aBufferSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aBufferSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStream=%p aProgress=%p hrc=%Rhrc\n", this, "MediumIO::convertToStream", !RT_VALID_PTR(aStream) ? 0 : *aStream, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "MediumIO::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::close", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod1IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod2IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod3IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod4IMediumIO()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumIOWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumIOWrap, IMediumIO)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumIOWrap.cpp"


// ##### BEGINFILE "MousePointerShapeWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMousePointerShape.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MOUSEPOINTERSHAPE

#include "MousePointerShapeWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MousePointerShapeWrap)

//
// IMousePointerShape properties
//

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "MousePointerShape::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "MousePointerShape::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Alpha)(BOOL *aAlpha)
{
    LogRelFlow(("{%p} %s: enter aAlpha=%p\n", this, "MousePointerShape::getAlpha", aAlpha));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAlpha);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAlpha(aAlpha);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 0 /*normal*/,*aAlpha != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 1 /*hrc exception*/,*aAlpha != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 9 /*unhandled exception*/,*aAlpha != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAlpha=%RTbool hrc=%Rhrc\n", this, "MousePointerShape::getAlpha", !RT_VALID_PTR(aAlpha) ? 0 : *aAlpha, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(HotX)(ULONG *aHotX)
{
    LogRelFlow(("{%p} %s: enter aHotX=%p\n", this, "MousePointerShape::getHotX", aHotX));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotX);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotX(aHotX);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 0 /*normal*/,*aHotX);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 1 /*hrc exception*/,*aHotX);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotX);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotX=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHotX", !RT_VALID_PTR(aHotX) ? 0 : *aHotX, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(HotY)(ULONG *aHotY)
{
    LogRelFlow(("{%p} %s: enter aHotY=%p\n", this, "MousePointerShape::getHotY", aHotY));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotY);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotY(aHotY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 0 /*normal*/,*aHotY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 1 /*hrc exception*/,*aHotY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotY);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotY=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHotY", !RT_VALID_PTR(aHotY) ? 0 : *aHotY, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "MousePointerShape::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getWidth", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "MousePointerShape::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHeight", !RT_VALID_PTR(aHeight) ? 0 : *aHeight, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Shape)(ComSafeArrayOut(BYTE, aShape))
{
    LogRelFlow(("{%p} %s: enter aShape=%p\n", this, "MousePointerShape::getShape", aShape));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShape);
        ArrayOutConverter<BYTE> TmpShape(ComSafeArrayOutArg(aShape));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShape(TmpShape.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpShape.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShape=%zu hrc=%Rhrc\n", this, "MousePointerShape::getShape", !RT_VALID_PTR(aShape) ? 0 : ComSafeArraySize(*aShape), hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute1IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute2IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute3IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute4IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMousePointerShape methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MousePointerShapeWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MousePointerShapeWrap, IMousePointerShape)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MousePointerShapeWrap.cpp"


// ##### BEGINFILE "DisplaySourceBitmapWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDisplaySourceBitmap.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_DISPLAYSOURCEBITMAP

#include "DisplaySourceBitmapWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DisplaySourceBitmapWrap)

//
// IDisplaySourceBitmap properties
//

STDMETHODIMP DisplaySourceBitmapWrap::COMGETTER(ScreenId)(ULONG *aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%p\n", this, "DisplaySourceBitmap::getScreenId", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenId(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 0 /*normal*/,*aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 1 /*hrc exception*/,*aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 9 /*unhandled exception*/,*aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreenId=%RU32 hrc=%Rhrc\n", this, "DisplaySourceBitmap::getScreenId", !RT_VALID_PTR(aScreenId) ? 0 : *aScreenId, hrc));
    return hrc;
}


//
// IDisplaySourceBitmap methods
//

STDMETHODIMP DisplaySourceBitmapWrap::QueryBitmapInfo(BYTE **aAddress,
                                                      ULONG *aWidth,
                                                      ULONG *aHeight,
                                                      ULONG *aBitsPerPixel,
                                                      ULONG *aBytesPerLine,
                                                      BitmapFormat_T *aBitmapFormat)
{
    LogRelFlow(("{%p} %s: enter aAddress=%p aWidth=%p aHeight=%p aBitsPerPixel=%p aBytesPerLine=%p aBitmapFormat=%p\n", this, "DisplaySourceBitmap::queryBitmapInfo", aAddress, aWidth, aHeight, aBitsPerPixel, aBytesPerLine, aBitmapFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAddress);
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        CheckComArgOutPointerValidThrow(aBytesPerLine);
        CheckComArgOutPointerValidThrow(aBitmapFormat);


        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryBitmapInfo(aAddress,
                                  aWidth,
                                  aHeight,
                                  aBitsPerPixel,
                                  aBytesPerLine,
                                  aBitmapFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 0 /*normal*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 1 /*hrc exception*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 9 /*unhandled exception*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAddress=%p *aWidth=%RU32 *aHeight=%RU32 *aBitsPerPixel=%RU32 *aBytesPerLine=%RU32 *aBitmapFormat=%RU32 hrc=%Rhrc\n", this, "DisplaySourceBitmap::queryBitmapInfo", !RT_VALID_PTR(aAddress) ? 0 : *aAddress, !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aBitsPerPixel) ? 0 : *aBitsPerPixel, !RT_VALID_PTR(aBytesPerLine) ? 0 : *aBytesPerLine, !RT_VALID_PTR(aBitmapFormat) ? 0 : *aBitmapFormat, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DisplaySourceBitmapWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DisplaySourceBitmapWrap, IDisplaySourceBitmap)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DisplaySourceBitmapWrap.cpp"


// ##### BEGINFILE "FramebufferWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFramebuffer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_FRAMEBUFFER

#include "FramebufferWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FramebufferWrap)

//
// IFramebuffer properties
//

STDMETHODIMP FramebufferWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "Framebuffer::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getWidth", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "Framebuffer::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getHeight", !RT_VALID_PTR(aHeight) ? 0 : *aHeight, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(BitsPerPixel)(ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aBitsPerPixel=%p\n", this, "Framebuffer::getBitsPerPixel", aBitsPerPixel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBitsPerPixel(aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 0 /*normal*/,*aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 1 /*hrc exception*/,*aBitsPerPixel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getBitsPerPixel", !RT_VALID_PTR(aBitsPerPixel) ? 0 : *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(BytesPerLine)(ULONG *aBytesPerLine)
{
    LogRelFlow(("{%p} %s: enter aBytesPerLine=%p\n", this, "Framebuffer::getBytesPerLine", aBytesPerLine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesPerLine);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesPerLine(aBytesPerLine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 0 /*normal*/,*aBytesPerLine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesPerLine);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesPerLine);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesPerLine=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getBytesPerLine", !RT_VALID_PTR(aBytesPerLine) ? 0 : *aBytesPerLine, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(PixelFormat)(BitmapFormat_T *aPixelFormat)
{
    LogRelFlow(("{%p} %s: enter aPixelFormat=%p\n", this, "Framebuffer::getPixelFormat", aPixelFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPixelFormat);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPixelFormat(aPixelFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 0 /*normal*/,*aPixelFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 1 /*hrc exception*/,*aPixelFormat);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPixelFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPixelFormat=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getPixelFormat", !RT_VALID_PTR(aPixelFormat) ? 0 : *aPixelFormat, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(HeightReduction)(ULONG *aHeightReduction)
{
    LogRelFlow(("{%p} %s: enter aHeightReduction=%p\n", this, "Framebuffer::getHeightReduction", aHeightReduction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeightReduction);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeightReduction(aHeightReduction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 0 /*normal*/,*aHeightReduction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 1 /*hrc exception*/,*aHeightReduction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeightReduction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeightReduction=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getHeightReduction", !RT_VALID_PTR(aHeightReduction) ? 0 : *aHeightReduction, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Overlay)(IFramebufferOverlay **aOverlay)
{
    LogRelFlow(("{%p} %s: enter aOverlay=%p\n", this, "Framebuffer::getOverlay", aOverlay));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOverlay);
        ComTypeOutConverter<IFramebufferOverlay> TmpOverlay(aOverlay);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOverlay(TmpOverlay.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 0 /*normal*/,(void *)TmpOverlay.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOverlay=%p hrc=%Rhrc\n", this, "Framebuffer::getOverlay", !RT_VALID_PTR(aOverlay) ? 0 : *aOverlay, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(WinId)(LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s: enter aWinId=%p\n", this, "Framebuffer::getWinId", aWinId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWinId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWinId(aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 0 /*normal*/,*aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 1 /*hrc exception*/,*aWinId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 9 /*unhandled exception*/,*aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWinId=%RI64 hrc=%Rhrc\n", this, "Framebuffer::getWinId", !RT_VALID_PTR(aWinId) ? 0 : *aWinId, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Capabilities)(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities))
{
    LogRelFlow(("{%p} %s: enter aCapabilities=%p\n", this, "Framebuffer::getCapabilities", aCapabilities));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCapabilities);
        ArrayOutConverter<FramebufferCapabilities_T> TmpCapabilities(ComSafeArrayOutArg(aCapabilities));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCapabilities(TmpCapabilities.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpCapabilities.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCapabilities=%zu hrc=%Rhrc\n", this, "Framebuffer::getCapabilities", !RT_VALID_PTR(aCapabilities) ? 0 : ComSafeArraySize(*aCapabilities), hrc));
    return hrc;
}


//
// IFramebuffer methods
//

STDMETHODIMP FramebufferWrap::NotifyUpdate(ULONG aX,
                                           ULONG aY,
                                           ULONG aWidth,
                                           ULONG aHeight)
{
    LogRelFlow(("{%p} %s: enter aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Framebuffer::notifyUpdate", aX, aY, aWidth, aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_ENTER(this, aX, aY, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyUpdate(aX,
                               aY,
                               aWidth,
                               aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyUpdate", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::NotifyUpdateImage(ULONG aX,
                                                ULONG aY,
                                                ULONG aWidth,
                                                ULONG aHeight,
                                                ComSafeArrayIn(BYTE, aImage))
{
    LogRelFlow(("{%p} %s: enter aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32 aImage=%zu\n", this, "Framebuffer::notifyUpdateImage", aX, aY, aWidth, aHeight, aImage));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        ArrayInConverter<BYTE> TmpImage(ComSafeArrayInArg(aImage));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_ENTER(this, aX, aY, aWidth, aHeight, (uint32_t)TmpImage.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyUpdateImage(aX,
                                    aY,
                                    aWidth,
                                    aHeight,
                                    TmpImage.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aWidth, aHeight, (uint32_t)TmpImage.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY, aWidth, aHeight, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyUpdateImage", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::NotifyChange(ULONG aScreenId,
                                           ULONG aXOrigin,
                                           ULONG aYOrigin,
                                           ULONG aWidth,
                                           ULONG aHeight)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aXOrigin=%RU32 aYOrigin=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Framebuffer::notifyChange", aScreenId, aXOrigin, aYOrigin, aWidth, aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_ENTER(this, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyChange(aScreenId,
                               aXOrigin,
                               aYOrigin,
                               aWidth,
                               aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyChange", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::VideoModeSupported(ULONG aWidth,
                                                 ULONG aHeight,
                                                 ULONG aBpp,
                                                 BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aWidth=%RU32 aHeight=%RU32 aBpp=%RU32 aSupported=%p\n", this, "Framebuffer::videoModeSupported", aWidth, aHeight, aBpp, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_ENTER(this, aWidth, aHeight, aBpp);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = videoModeSupported(aWidth,
                                     aHeight,
                                     aBpp,
                                     aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 0 /*normal*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "Framebuffer::videoModeSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::GetVisibleRegion(BYTE *aRectangles,
                                               ULONG aCount,
                                               ULONG *aCountCopied)
{
    LogRelFlow(("{%p} %s: enter aRectangles=%p aCount=%RU32 aCountCopied=%p\n", this, "Framebuffer::getVisibleRegion", aRectangles, aCount, aCountCopied));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCountCopied);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_ENTER(this, aRectangles, aCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisibleRegion(aRectangles,
                                   aCount,
                                   aCountCopied);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount, *aCountCopied);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 1 /*hrc exception*/, aRectangles, aCount, *aCountCopied);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount, *aCountCopied);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCountCopied=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getVisibleRegion", !RT_VALID_PTR(aCountCopied) ? 0 : *aCountCopied, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::SetVisibleRegion(BYTE *aRectangles,
                                               ULONG aCount)
{
    LogRelFlow(("{%p} %s: enter aRectangles=%p aCount=%RU32\n", this, "Framebuffer::setVisibleRegion", aRectangles, aCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_ENTER(this, aRectangles, aCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVisibleRegion(aRectangles,
                                   aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 1 /*hrc exception*/, aRectangles, aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::setVisibleRegion", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::ProcessVHWACommand(BYTE *aCommand,
                                                 LONG aEnmCmd,
                                                 BOOL aFromGuest)
{
    LogRelFlow(("{%p} %s: enter aCommand=%p aEnmCmd=%RI32 aFromGuest=%RTbool\n", this, "Framebuffer::processVHWACommand", aCommand, aEnmCmd, aFromGuest));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_ENTER(this, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = processVHWACommand(aCommand,
                                     aEnmCmd,
                                     aFromGuest != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 0 /*normal*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 1 /*hrc exception*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::processVHWACommand", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::Notify3DEvent(ULONG aType,
                                            ComSafeArrayIn(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aData=%zu\n", this, "Framebuffer::notify3DEvent", aType, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_ENTER(this, aType, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notify3DEvent(aType,
                                TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 0 /*normal*/, aType, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notify3DEvent", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FramebufferWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FramebufferWrap, IFramebuffer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FramebufferWrap.cpp"


// ##### BEGINFILE "GuestScreenInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestScreenInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTSCREENINFO

#include "GuestScreenInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestScreenInfoWrap)

//
// IGuestScreenInfo properties
//

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(ScreenId)(ULONG *aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%p\n", this, "GuestScreenInfo::getScreenId", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenId(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 0 /*normal*/,*aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 1 /*hrc exception*/,*aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 9 /*unhandled exception*/,*aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreenId=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getScreenId", !RT_VALID_PTR(aScreenId) ? 0 : *aScreenId, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(GuestMonitorStatus)(GuestMonitorStatus_T *aGuestMonitorStatus)
{
    LogRelFlow(("{%p} %s: enter aGuestMonitorStatus=%p\n", this, "GuestScreenInfo::getGuestMonitorStatus", aGuestMonitorStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestMonitorStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestMonitorStatus(aGuestMonitorStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 0 /*normal*/,*aGuestMonitorStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aGuestMonitorStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aGuestMonitorStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestMonitorStatus=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getGuestMonitorStatus", !RT_VALID_PTR(aGuestMonitorStatus) ? 0 : *aGuestMonitorStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Primary)(BOOL *aPrimary)
{
    LogRelFlow(("{%p} %s: enter aPrimary=%p\n", this, "GuestScreenInfo::getPrimary", aPrimary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPrimary);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPrimary(aPrimary);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 0 /*normal*/,*aPrimary != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 1 /*hrc exception*/,*aPrimary != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 9 /*unhandled exception*/,*aPrimary != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPrimary=%RTbool hrc=%Rhrc\n", this, "GuestScreenInfo::getPrimary", !RT_VALID_PTR(aPrimary) ? 0 : *aPrimary, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Origin)(BOOL *aOrigin)
{
    LogRelFlow(("{%p} %s: enter aOrigin=%p\n", this, "GuestScreenInfo::getOrigin", aOrigin));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOrigin);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOrigin(aOrigin);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 0 /*normal*/,*aOrigin != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 1 /*hrc exception*/,*aOrigin != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aOrigin != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOrigin=%RTbool hrc=%Rhrc\n", this, "GuestScreenInfo::getOrigin", !RT_VALID_PTR(aOrigin) ? 0 : *aOrigin, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(OriginX)(LONG *aOriginX)
{
    LogRelFlow(("{%p} %s: enter aOriginX=%p\n", this, "GuestScreenInfo::getOriginX", aOriginX));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOriginX);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOriginX(aOriginX);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 0 /*normal*/,*aOriginX);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 1 /*hrc exception*/,*aOriginX);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 9 /*unhandled exception*/,*aOriginX);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOriginX=%RI32 hrc=%Rhrc\n", this, "GuestScreenInfo::getOriginX", !RT_VALID_PTR(aOriginX) ? 0 : *aOriginX, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(OriginY)(LONG *aOriginY)
{
    LogRelFlow(("{%p} %s: enter aOriginY=%p\n", this, "GuestScreenInfo::getOriginY", aOriginY));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOriginY);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOriginY(aOriginY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 0 /*normal*/,*aOriginY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 1 /*hrc exception*/,*aOriginY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 9 /*unhandled exception*/,*aOriginY);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOriginY=%RI32 hrc=%Rhrc\n", this, "GuestScreenInfo::getOriginY", !RT_VALID_PTR(aOriginY) ? 0 : *aOriginY, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "GuestScreenInfo::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getWidth", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "GuestScreenInfo::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getHeight", !RT_VALID_PTR(aHeight) ? 0 : *aHeight, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(BitsPerPixel)(ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aBitsPerPixel=%p\n", this, "GuestScreenInfo::getBitsPerPixel", aBitsPerPixel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBitsPerPixel(aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 0 /*normal*/,*aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 1 /*hrc exception*/,*aBitsPerPixel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getBitsPerPixel", !RT_VALID_PTR(aBitsPerPixel) ? 0 : *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(ExtendedInfo)(BSTR *aExtendedInfo)
{
    LogRelFlow(("{%p} %s: enter aExtendedInfo=%p\n", this, "GuestScreenInfo::getExtendedInfo", aExtendedInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtendedInfo);
        BSTROutConverter TmpExtendedInfo(aExtendedInfo);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtendedInfo(TmpExtendedInfo.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 0 /*normal*/,TmpExtendedInfo.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtendedInfo=%ls hrc=%Rhrc\n", this, "GuestScreenInfo::getExtendedInfo", !RT_VALID_PTR(aExtendedInfo) ? 0 : *aExtendedInfo, hrc));
    return hrc;
}


//
// IGuestScreenInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestScreenInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestScreenInfoWrap, IGuestScreenInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestScreenInfoWrap.cpp"


// ##### BEGINFILE "SerialPortWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISerialPort.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_SERIALPORT

#include "SerialPortWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SerialPortWrap)

//
// ISerialPort properties
//

STDMETHODIMP SerialPortWrap::COMGETTER(Slot)(ULONG *aSlot)
{
    LogRelFlow(("{%p} %s: enter aSlot=%p\n", this, "SerialPort::getSlot", aSlot));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSlot);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSlot(aSlot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 0 /*normal*/,*aSlot);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 1 /*hrc exception*/,*aSlot);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSlot);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSlot=%RU32 hrc=%Rhrc\n", this, "SerialPort::getSlot", !RT_VALID_PTR(aSlot) ? 0 : *aSlot, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "SerialPort::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "SerialPort::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "SerialPort::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(IOAddress)(ULONG *aIOAddress)
{
    LogRelFlow(("{%p} %s: enter aIOAddress=%p\n", this, "SerialPort::getIOAddress", aIOAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIOAddress);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IOADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOAddress(aIOAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IOADDRESS_RETURN(this, hrc, 0 /*normal*/,*aIOAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IOADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,*aIOAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IOADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOAddress=%RU32 hrc=%Rhrc\n", this, "SerialPort::getIOAddress", !RT_VALID_PTR(aIOAddress) ? 0 : *aIOAddress, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(IOAddress)(ULONG aIOAddress)
{
    LogRelFlow(("{%p} %s: enter aIOAddress=%RU32\n", this, "SerialPort::setIOAddress", aIOAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IOADDRESS_ENTER(this, aIOAddress);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOAddress(aIOAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IOADDRESS_RETURN(this, hrc, 0 /*normal*/,aIOAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IOADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,aIOAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IOADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,aIOAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setIOAddress", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(IRQ)(ULONG *aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%p\n", this, "SerialPort::getIRQ", aIRQ));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIRQ);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIRQ(aIRQ);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 0 /*normal*/,*aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 1 /*hrc exception*/,*aIRQ);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,*aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIRQ=%RU32 hrc=%Rhrc\n", this, "SerialPort::getIRQ", !RT_VALID_PTR(aIRQ) ? 0 : *aIRQ, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(IRQ)(ULONG aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%RU32\n", this, "SerialPort::setIRQ", aIRQ));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_ENTER(this, aIRQ);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIRQ(aIRQ);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 0 /*normal*/,aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 1 /*hrc exception*/,aIRQ);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setIRQ", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(HostMode)(PortMode_T *aHostMode)
{
    LogRelFlow(("{%p} %s: enter aHostMode=%p\n", this, "SerialPort::getHostMode", aHostMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostMode(aHostMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 0 /*normal*/,*aHostMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aHostMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHostMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostMode=%RU32 hrc=%Rhrc\n", this, "SerialPort::getHostMode", !RT_VALID_PTR(aHostMode) ? 0 : *aHostMode, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(HostMode)(PortMode_T aHostMode)
{
    LogRelFlow(("{%p} %s: enter aHostMode=%RU32\n", this, "SerialPort::setHostMode", aHostMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_ENTER(this, aHostMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostMode(aHostMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 0 /*normal*/,aHostMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 1 /*hrc exception*/,aHostMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aHostMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setHostMode", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Server)(BOOL *aServer)
{
    LogRelFlow(("{%p} %s: enter aServer=%p\n", this, "SerialPort::getServer", aServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getServer(aServer);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 0 /*normal*/,*aServer != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 1 /*hrc exception*/,*aServer != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aServer != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aServer=%RTbool hrc=%Rhrc\n", this, "SerialPort::getServer", !RT_VALID_PTR(aServer) ? 0 : *aServer, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Server)(BOOL aServer)
{
    LogRelFlow(("{%p} %s: enter aServer=%RTbool\n", this, "SerialPort::setServer", aServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_ENTER(this, aServer != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setServer(aServer != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 0 /*normal*/,aServer != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 1 /*hrc exception*/,aServer != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 9 /*unhandled exception*/,aServer != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setServer", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "SerialPort::getPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPath);
        BSTROutConverter TmpPath(aPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPath=%ls hrc=%Rhrc\n", this, "SerialPort::getPath", !RT_VALID_PTR(aPath) ? 0 : *aPath, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Path)(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "SerialPort::setPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setPath", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(UartType)(UartType_T *aUartType)
{
    LogRelFlow(("{%p} %s: enter aUartType=%p\n", this, "SerialPort::getUartType", aUartType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUartType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUartType(aUartType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 0 /*normal*/,*aUartType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aUartType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUartType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUartType=%RU32 hrc=%Rhrc\n", this, "SerialPort::getUartType", !RT_VALID_PTR(aUartType) ? 0 : *aUartType, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(UartType)(UartType_T aUartType)
{
    LogRelFlow(("{%p} %s: enter aUartType=%RU32\n", this, "SerialPort::setUartType", aUartType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_ENTER(this, aUartType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUartType(aUartType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 0 /*normal*/,aUartType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aUartType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aUartType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setUartType", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute1ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute2ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute3ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute4ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISerialPort methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SerialPortWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SerialPortWrap, ISerialPort)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SerialPortWrap.cpp"


// ##### BEGINFILE "MachineDebuggerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMachineDebugger.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MACHINEDEBUGGER

#include "MachineDebuggerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MachineDebuggerWrap)

//
// IMachineDebugger properties
//

STDMETHODIMP MachineDebuggerWrap::COMGETTER(SingleStep)(BOOL *aSingleStep)
{
    LogRelFlow(("{%p} %s: enter aSingleStep=%p\n", this, "MachineDebugger::getSingleStep", aSingleStep));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSingleStep);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_SINGLESTEP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSingleStep(aSingleStep);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_SINGLESTEP_RETURN(this, hrc, 0 /*normal*/,*aSingleStep != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_SINGLESTEP_RETURN(this, hrc, 1 /*hrc exception*/,*aSingleStep != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_SINGLESTEP_RETURN(this, hrc, 9 /*unhandled exception*/,*aSingleStep != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSingleStep=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getSingleStep", !RT_VALID_PTR(aSingleStep) ? 0 : *aSingleStep, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMSETTER(SingleStep)(BOOL aSingleStep)
{
    LogRelFlow(("{%p} %s: enter aSingleStep=%RTbool\n", this, "MachineDebugger::setSingleStep", aSingleStep));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_SINGLESTEP_ENTER(this, aSingleStep != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSingleStep(aSingleStep != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_SINGLESTEP_RETURN(this, hrc, 0 /*normal*/,aSingleStep != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_SINGLESTEP_RETURN(this, hrc, 1 /*hrc exception*/,aSingleStep != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_SINGLESTEP_RETURN(this, hrc, 9 /*unhandled exception*/,aSingleStep != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setSingleStep", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(ExecuteAllInIEM)(BOOL *aExecuteAllInIEM)
{
    LogRelFlow(("{%p} %s: enter aExecuteAllInIEM=%p\n", this, "MachineDebugger::getExecuteAllInIEM", aExecuteAllInIEM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExecuteAllInIEM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTEALLINIEM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExecuteAllInIEM(aExecuteAllInIEM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTEALLINIEM_RETURN(this, hrc, 0 /*normal*/,*aExecuteAllInIEM != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTEALLINIEM_RETURN(this, hrc, 1 /*hrc exception*/,*aExecuteAllInIEM != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTEALLINIEM_RETURN(this, hrc, 9 /*unhandled exception*/,*aExecuteAllInIEM != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExecuteAllInIEM=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getExecuteAllInIEM", !RT_VALID_PTR(aExecuteAllInIEM) ? 0 : *aExecuteAllInIEM, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMSETTER(ExecuteAllInIEM)(BOOL aExecuteAllInIEM)
{
    LogRelFlow(("{%p} %s: enter aExecuteAllInIEM=%RTbool\n", this, "MachineDebugger::setExecuteAllInIEM", aExecuteAllInIEM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_EXECUTEALLINIEM_ENTER(this, aExecuteAllInIEM != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setExecuteAllInIEM(aExecuteAllInIEM != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_EXECUTEALLINIEM_RETURN(this, hrc, 0 /*normal*/,aExecuteAllInIEM != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_EXECUTEALLINIEM_RETURN(this, hrc, 1 /*hrc exception*/,aExecuteAllInIEM != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_EXECUTEALLINIEM_RETURN(this, hrc, 9 /*unhandled exception*/,aExecuteAllInIEM != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setExecuteAllInIEM", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogEnabled)(BOOL *aLogEnabled)
{
    LogRelFlow(("{%p} %s: enter aLogEnabled=%p\n", this, "MachineDebugger::getLogEnabled", aLogEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogEnabled(aLogEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGENABLED_RETURN(this, hrc, 0 /*normal*/,*aLogEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aLogEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogEnabled=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getLogEnabled", !RT_VALID_PTR(aLogEnabled) ? 0 : *aLogEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMSETTER(LogEnabled)(BOOL aLogEnabled)
{
    LogRelFlow(("{%p} %s: enter aLogEnabled=%RTbool\n", this, "MachineDebugger::setLogEnabled", aLogEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_LOGENABLED_ENTER(this, aLogEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogEnabled(aLogEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_LOGENABLED_RETURN(this, hrc, 0 /*normal*/,aLogEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_LOGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aLogEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_LOGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aLogEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setLogEnabled", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogDbgFlags)(BSTR *aLogDbgFlags)
{
    LogRelFlow(("{%p} %s: enter aLogDbgFlags=%p\n", this, "MachineDebugger::getLogDbgFlags", aLogDbgFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogDbgFlags);
        BSTROutConverter TmpLogDbgFlags(aLogDbgFlags);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGFLAGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogDbgFlags(TmpLogDbgFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGFLAGS_RETURN(this, hrc, 0 /*normal*/,TmpLogDbgFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGFLAGS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogDbgFlags=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogDbgFlags", !RT_VALID_PTR(aLogDbgFlags) ? 0 : *aLogDbgFlags, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogDbgGroups)(BSTR *aLogDbgGroups)
{
    LogRelFlow(("{%p} %s: enter aLogDbgGroups=%p\n", this, "MachineDebugger::getLogDbgGroups", aLogDbgGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogDbgGroups);
        BSTROutConverter TmpLogDbgGroups(aLogDbgGroups);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogDbgGroups(TmpLogDbgGroups.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGGROUPS_RETURN(this, hrc, 0 /*normal*/,TmpLogDbgGroups.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGGROUPS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogDbgGroups=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogDbgGroups", !RT_VALID_PTR(aLogDbgGroups) ? 0 : *aLogDbgGroups, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogDbgDestinations)(BSTR *aLogDbgDestinations)
{
    LogRelFlow(("{%p} %s: enter aLogDbgDestinations=%p\n", this, "MachineDebugger::getLogDbgDestinations", aLogDbgDestinations));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogDbgDestinations);
        BSTROutConverter TmpLogDbgDestinations(aLogDbgDestinations);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGDESTINATIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogDbgDestinations(TmpLogDbgDestinations.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGDESTINATIONS_RETURN(this, hrc, 0 /*normal*/,TmpLogDbgDestinations.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGDESTINATIONS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGDBGDESTINATIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogDbgDestinations=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogDbgDestinations", !RT_VALID_PTR(aLogDbgDestinations) ? 0 : *aLogDbgDestinations, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogRelFlags)(BSTR *aLogRelFlags)
{
    LogRelFlow(("{%p} %s: enter aLogRelFlags=%p\n", this, "MachineDebugger::getLogRelFlags", aLogRelFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogRelFlags);
        BSTROutConverter TmpLogRelFlags(aLogRelFlags);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELFLAGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogRelFlags(TmpLogRelFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELFLAGS_RETURN(this, hrc, 0 /*normal*/,TmpLogRelFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELFLAGS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogRelFlags=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogRelFlags", !RT_VALID_PTR(aLogRelFlags) ? 0 : *aLogRelFlags, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogRelGroups)(BSTR *aLogRelGroups)
{
    LogRelFlow(("{%p} %s: enter aLogRelGroups=%p\n", this, "MachineDebugger::getLogRelGroups", aLogRelGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogRelGroups);
        BSTROutConverter TmpLogRelGroups(aLogRelGroups);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogRelGroups(TmpLogRelGroups.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELGROUPS_RETURN(this, hrc, 0 /*normal*/,TmpLogRelGroups.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELGROUPS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogRelGroups=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogRelGroups", !RT_VALID_PTR(aLogRelGroups) ? 0 : *aLogRelGroups, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(LogRelDestinations)(BSTR *aLogRelDestinations)
{
    LogRelFlow(("{%p} %s: enter aLogRelDestinations=%p\n", this, "MachineDebugger::getLogRelDestinations", aLogRelDestinations));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogRelDestinations);
        BSTROutConverter TmpLogRelDestinations(aLogRelDestinations);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELDESTINATIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogRelDestinations(TmpLogRelDestinations.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELDESTINATIONS_RETURN(this, hrc, 0 /*normal*/,TmpLogRelDestinations.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELDESTINATIONS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_LOGRELDESTINATIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogRelDestinations=%ls hrc=%Rhrc\n", this, "MachineDebugger::getLogRelDestinations", !RT_VALID_PTR(aLogRelDestinations) ? 0 : *aLogRelDestinations, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(ExecutionEngine)(VMExecutionEngine_T *aExecutionEngine)
{
    LogRelFlow(("{%p} %s: enter aExecutionEngine=%p\n", this, "MachineDebugger::getExecutionEngine", aExecutionEngine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExecutionEngine);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTIONENGINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExecutionEngine(aExecutionEngine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTIONENGINE_RETURN(this, hrc, 0 /*normal*/,*aExecutionEngine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTIONENGINE_RETURN(this, hrc, 1 /*hrc exception*/,*aExecutionEngine);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_EXECUTIONENGINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aExecutionEngine);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExecutionEngine=%RU32 hrc=%Rhrc\n", this, "MachineDebugger::getExecutionEngine", !RT_VALID_PTR(aExecutionEngine) ? 0 : *aExecutionEngine, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(HWVirtExNestedPagingEnabled)(BOOL *aHWVirtExNestedPagingEnabled)
{
    LogRelFlow(("{%p} %s: enter aHWVirtExNestedPagingEnabled=%p\n", this, "MachineDebugger::getHWVirtExNestedPagingEnabled", aHWVirtExNestedPagingEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHWVirtExNestedPagingEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXNESTEDPAGINGENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHWVirtExNestedPagingEnabled(aHWVirtExNestedPagingEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXNESTEDPAGINGENABLED_RETURN(this, hrc, 0 /*normal*/,*aHWVirtExNestedPagingEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXNESTEDPAGINGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aHWVirtExNestedPagingEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXNESTEDPAGINGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aHWVirtExNestedPagingEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHWVirtExNestedPagingEnabled=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getHWVirtExNestedPagingEnabled", !RT_VALID_PTR(aHWVirtExNestedPagingEnabled) ? 0 : *aHWVirtExNestedPagingEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(HWVirtExVPIDEnabled)(BOOL *aHWVirtExVPIDEnabled)
{
    LogRelFlow(("{%p} %s: enter aHWVirtExVPIDEnabled=%p\n", this, "MachineDebugger::getHWVirtExVPIDEnabled", aHWVirtExVPIDEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHWVirtExVPIDEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXVPIDENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHWVirtExVPIDEnabled(aHWVirtExVPIDEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXVPIDENABLED_RETURN(this, hrc, 0 /*normal*/,*aHWVirtExVPIDEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXVPIDENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aHWVirtExVPIDEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXVPIDENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aHWVirtExVPIDEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHWVirtExVPIDEnabled=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getHWVirtExVPIDEnabled", !RT_VALID_PTR(aHWVirtExVPIDEnabled) ? 0 : *aHWVirtExVPIDEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(HWVirtExUXEnabled)(BOOL *aHWVirtExUXEnabled)
{
    LogRelFlow(("{%p} %s: enter aHWVirtExUXEnabled=%p\n", this, "MachineDebugger::getHWVirtExUXEnabled", aHWVirtExUXEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHWVirtExUXEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXUXENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHWVirtExUXEnabled(aHWVirtExUXEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXUXENABLED_RETURN(this, hrc, 0 /*normal*/,*aHWVirtExUXEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXUXENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aHWVirtExUXEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_HWVIRTEXUXENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aHWVirtExUXEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHWVirtExUXEnabled=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getHWVirtExUXEnabled", !RT_VALID_PTR(aHWVirtExUXEnabled) ? 0 : *aHWVirtExUXEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(OSName)(BSTR *aOSName)
{
    LogRelFlow(("{%p} %s: enter aOSName=%p\n", this, "MachineDebugger::getOSName", aOSName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOSName);
        BSTROutConverter TmpOSName(aOSName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOSName(TmpOSName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSNAME_RETURN(this, hrc, 0 /*normal*/,TmpOSName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOSName=%ls hrc=%Rhrc\n", this, "MachineDebugger::getOSName", !RT_VALID_PTR(aOSName) ? 0 : *aOSName, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(OSVersion)(BSTR *aOSVersion)
{
    LogRelFlow(("{%p} %s: enter aOSVersion=%p\n", this, "MachineDebugger::getOSVersion", aOSVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOSVersion);
        BSTROutConverter TmpOSVersion(aOSVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOSVersion(TmpOSVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSVERSION_RETURN(this, hrc, 0 /*normal*/,TmpOSVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_OSVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOSVersion=%ls hrc=%Rhrc\n", this, "MachineDebugger::getOSVersion", !RT_VALID_PTR(aOSVersion) ? 0 : *aOSVersion, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(PAEEnabled)(BOOL *aPAEEnabled)
{
    LogRelFlow(("{%p} %s: enter aPAEEnabled=%p\n", this, "MachineDebugger::getPAEEnabled", aPAEEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPAEEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_PAEENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPAEEnabled(aPAEEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_PAEENABLED_RETURN(this, hrc, 0 /*normal*/,*aPAEEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_PAEENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aPAEEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_PAEENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aPAEEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPAEEnabled=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getPAEEnabled", !RT_VALID_PTR(aPAEEnabled) ? 0 : *aPAEEnabled, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(VirtualTimeRate)(ULONG *aVirtualTimeRate)
{
    LogRelFlow(("{%p} %s: enter aVirtualTimeRate=%p\n", this, "MachineDebugger::getVirtualTimeRate", aVirtualTimeRate));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVirtualTimeRate);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_VIRTUALTIMERATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVirtualTimeRate(aVirtualTimeRate);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_VIRTUALTIMERATE_RETURN(this, hrc, 0 /*normal*/,*aVirtualTimeRate);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_VIRTUALTIMERATE_RETURN(this, hrc, 1 /*hrc exception*/,*aVirtualTimeRate);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_VIRTUALTIMERATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVirtualTimeRate);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVirtualTimeRate=%RU32 hrc=%Rhrc\n", this, "MachineDebugger::getVirtualTimeRate", !RT_VALID_PTR(aVirtualTimeRate) ? 0 : *aVirtualTimeRate, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMSETTER(VirtualTimeRate)(ULONG aVirtualTimeRate)
{
    LogRelFlow(("{%p} %s: enter aVirtualTimeRate=%RU32\n", this, "MachineDebugger::setVirtualTimeRate", aVirtualTimeRate));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_VIRTUALTIMERATE_ENTER(this, aVirtualTimeRate);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVirtualTimeRate(aVirtualTimeRate);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_VIRTUALTIMERATE_RETURN(this, hrc, 0 /*normal*/,aVirtualTimeRate);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_VIRTUALTIMERATE_RETURN(this, hrc, 1 /*hrc exception*/,aVirtualTimeRate);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_VIRTUALTIMERATE_RETURN(this, hrc, 9 /*unhandled exception*/,aVirtualTimeRate);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setVirtualTimeRate", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(Uptime)(LONG64 *aUptime)
{
    LogRelFlow(("{%p} %s: enter aUptime=%p\n", this, "MachineDebugger::getUptime", aUptime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUptime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_UPTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUptime(aUptime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_UPTIME_RETURN(this, hrc, 0 /*normal*/,*aUptime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_UPTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aUptime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_UPTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aUptime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUptime=%RI64 hrc=%Rhrc\n", this, "MachineDebugger::getUptime", !RT_VALID_PTR(aUptime) ? 0 : *aUptime, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(RecompiledIEMExecution)(BOOL *aRecompiledIEMExecution)
{
    LogRelFlow(("{%p} %s: enter aRecompiledIEMExecution=%p\n", this, "MachineDebugger::getRecompiledIEMExecution", aRecompiledIEMExecution));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecompiledIEMExecution);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_RECOMPILEDIEMEXECUTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecompiledIEMExecution(aRecompiledIEMExecution);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 0 /*normal*/,*aRecompiledIEMExecution != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 1 /*hrc exception*/,*aRecompiledIEMExecution != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecompiledIEMExecution != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecompiledIEMExecution=%RTbool hrc=%Rhrc\n", this, "MachineDebugger::getRecompiledIEMExecution", !RT_VALID_PTR(aRecompiledIEMExecution) ? 0 : *aRecompiledIEMExecution, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMSETTER(RecompiledIEMExecution)(BOOL aRecompiledIEMExecution)
{
    LogRelFlow(("{%p} %s: enter aRecompiledIEMExecution=%RTbool\n", this, "MachineDebugger::setRecompiledIEMExecution", aRecompiledIEMExecution));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_RECOMPILEDIEMEXECUTION_ENTER(this, aRecompiledIEMExecution != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRecompiledIEMExecution(aRecompiledIEMExecution != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 0 /*normal*/,aRecompiledIEMExecution != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 1 /*hrc exception*/,aRecompiledIEMExecution != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SET_RECOMPILEDIEMEXECUTION_RETURN(this, hrc, 9 /*unhandled exception*/,aRecompiledIEMExecution != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setRecompiledIEMExecution", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute1IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute2IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute3IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute4IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute5IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute6IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute7IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute8IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute9IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute10IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute11IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute12IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute13IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::COMGETTER(InternalAndReservedAttribute14IMachineDebugger)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMachineDebugger methods
//

STDMETHODIMP MachineDebuggerWrap::DumpGuestCore(IN_BSTR aFilename,
                                                IN_BSTR aCompression)
{
    LogRelFlow(("{%p} %s: enter aFilename=%ls aCompression=%ls\n", this, "MachineDebugger::dumpGuestCore", aFilename, aCompression));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpFilename(aFilename);
        BSTRInConverter TmpCompression(aCompression);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTCORE_ENTER(this, TmpFilename.str().c_str(), TmpCompression.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dumpGuestCore(TmpFilename.str(),
                                TmpCompression.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTCORE_RETURN(this, hrc, 0 /*normal*/, TmpFilename.str().c_str(), TmpCompression.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTCORE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTCORE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::dumpGuestCore", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::DumpHostProcessCore(IN_BSTR aFilename,
                                                      IN_BSTR aCompression)
{
    LogRelFlow(("{%p} %s: enter aFilename=%ls aCompression=%ls\n", this, "MachineDebugger::dumpHostProcessCore", aFilename, aCompression));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpFilename(aFilename);
        BSTRInConverter TmpCompression(aCompression);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPHOSTPROCESSCORE_ENTER(this, TmpFilename.str().c_str(), TmpCompression.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dumpHostProcessCore(TmpFilename.str(),
                                      TmpCompression.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPHOSTPROCESSCORE_RETURN(this, hrc, 0 /*normal*/, TmpFilename.str().c_str(), TmpCompression.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPHOSTPROCESSCORE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPHOSTPROCESSCORE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::dumpHostProcessCore", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::Info(IN_BSTR aName,
                                       IN_BSTR aArgs,
                                       BSTR *aInfo)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aArgs=%ls aInfo=%p\n", this, "MachineDebugger::info", aName, aArgs, aInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInfo);


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpArgs(aArgs);
        BSTROutConverter TmpInfo(aInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INFO_ENTER(this, TmpName.str().c_str(), TmpArgs.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = info(TmpName.str(),
                       TmpArgs.str(),
                       TmpInfo.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INFO_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpArgs.str().c_str(), TmpInfo.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INFO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aInfo=%ls hrc=%Rhrc\n", this, "MachineDebugger::info", !RT_VALID_PTR(aInfo) ? 0 : *aInfo, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::InjectNMI()
{
    LogRelFlow(("{%p} %s: enter\n", this, "MachineDebugger::injectNMI"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INJECTNMI_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = injectNMI();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INJECTNMI_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INJECTNMI_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_INJECTNMI_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::injectNMI", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ModifyLogGroups(IN_BSTR aSettings)
{
    LogRelFlow(("{%p} %s: enter aSettings=%ls\n", this, "MachineDebugger::modifyLogGroups", aSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSettings(aSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGGROUPS_ENTER(this, TmpSettings.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = modifyLogGroups(TmpSettings.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGGROUPS_RETURN(this, hrc, 0 /*normal*/, TmpSettings.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGGROUPS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::modifyLogGroups", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ModifyLogFlags(IN_BSTR aSettings)
{
    LogRelFlow(("{%p} %s: enter aSettings=%ls\n", this, "MachineDebugger::modifyLogFlags", aSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSettings(aSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGFLAGS_ENTER(this, TmpSettings.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = modifyLogFlags(TmpSettings.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGFLAGS_RETURN(this, hrc, 0 /*normal*/, TmpSettings.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGFLAGS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::modifyLogFlags", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ModifyLogDestinations(IN_BSTR aSettings)
{
    LogRelFlow(("{%p} %s: enter aSettings=%ls\n", this, "MachineDebugger::modifyLogDestinations", aSettings));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSettings(aSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGDESTINATIONS_ENTER(this, TmpSettings.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = modifyLogDestinations(TmpSettings.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGDESTINATIONS_RETURN(this, hrc, 0 /*normal*/, TmpSettings.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGDESTINATIONS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_MODIFYLOGDESTINATIONS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::modifyLogDestinations", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ReadPhysicalMemory(LONG64 aAddress,
                                                     ULONG aSize,
                                                     ComSafeArrayOut(BYTE, aBytes))
{
    LogRelFlow(("{%p} %s: enter aAddress=%RI64 aSize=%RU32 aBytes=%p\n", this, "MachineDebugger::readPhysicalMemory", aAddress, aSize, aBytes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytes);


        
        
        ArrayOutConverter<BYTE> TmpBytes(ComSafeArrayOutArg(aBytes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READPHYSICALMEMORY_ENTER(this, aAddress, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readPhysicalMemory(aAddress,
                                     aSize,
                                     TmpBytes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READPHYSICALMEMORY_RETURN(this, hrc, 0 /*normal*/, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READPHYSICALMEMORY_RETURN(this, hrc, 1 /*hrc exception*/, aAddress, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READPHYSICALMEMORY_RETURN(this, hrc, 9 /*unhandled exception*/, aAddress, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBytes=%zu hrc=%Rhrc\n", this, "MachineDebugger::readPhysicalMemory", !RT_VALID_PTR(aBytes) ? 0 : ComSafeArraySize(*aBytes), hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::WritePhysicalMemory(LONG64 aAddress,
                                                      ULONG aSize,
                                                      ComSafeArrayIn(BYTE, aBytes))
{
    LogRelFlow(("{%p} %s: enter aAddress=%RI64 aSize=%RU32 aBytes=%zu\n", this, "MachineDebugger::writePhysicalMemory", aAddress, aSize, aBytes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        ArrayInConverter<BYTE> TmpBytes(ComSafeArrayInArg(aBytes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEPHYSICALMEMORY_ENTER(this, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = writePhysicalMemory(aAddress,
                                      aSize,
                                      TmpBytes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEPHYSICALMEMORY_RETURN(this, hrc, 0 /*normal*/, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEPHYSICALMEMORY_RETURN(this, hrc, 1 /*hrc exception*/, aAddress, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEPHYSICALMEMORY_RETURN(this, hrc, 9 /*unhandled exception*/, aAddress, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::writePhysicalMemory", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ReadVirtualMemory(ULONG aCpuId,
                                                    LONG64 aAddress,
                                                    ULONG aSize,
                                                    ComSafeArrayOut(BYTE, aBytes))
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aAddress=%RI64 aSize=%RU32 aBytes=%p\n", this, "MachineDebugger::readVirtualMemory", aCpuId, aAddress, aSize, aBytes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytes);


        
        
        
        ArrayOutConverter<BYTE> TmpBytes(ComSafeArrayOutArg(aBytes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READVIRTUALMEMORY_ENTER(this, aCpuId, aAddress, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readVirtualMemory(aCpuId,
                                    aAddress,
                                    aSize,
                                    TmpBytes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READVIRTUALMEMORY_RETURN(this, hrc, 0 /*normal*/, aCpuId, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READVIRTUALMEMORY_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, aAddress, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_READVIRTUALMEMORY_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, aAddress, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBytes=%zu hrc=%Rhrc\n", this, "MachineDebugger::readVirtualMemory", !RT_VALID_PTR(aBytes) ? 0 : ComSafeArraySize(*aBytes), hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::WriteVirtualMemory(ULONG aCpuId,
                                                     LONG64 aAddress,
                                                     ULONG aSize,
                                                     ComSafeArrayIn(BYTE, aBytes))
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aAddress=%RI64 aSize=%RU32 aBytes=%zu\n", this, "MachineDebugger::writeVirtualMemory", aCpuId, aAddress, aSize, aBytes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        ArrayInConverter<BYTE> TmpBytes(ComSafeArrayInArg(aBytes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEVIRTUALMEMORY_ENTER(this, aCpuId, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = writeVirtualMemory(aCpuId,
                                     aAddress,
                                     aSize,
                                     TmpBytes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEVIRTUALMEMORY_RETURN(this, hrc, 0 /*normal*/, aCpuId, aAddress, aSize, (uint32_t)TmpBytes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEVIRTUALMEMORY_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, aAddress, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_WRITEVIRTUALMEMORY_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, aAddress, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::writeVirtualMemory", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::LoadPlugIn(IN_BSTR aName,
                                             BSTR *aPlugInName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aPlugInName=%p\n", this, "MachineDebugger::loadPlugIn", aName, aPlugInName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugInName);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpPlugInName(aPlugInName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_LOADPLUGIN_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = loadPlugIn(TmpName.str(),
                             TmpPlugInName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_LOADPLUGIN_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpPlugInName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_LOADPLUGIN_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_LOADPLUGIN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aPlugInName=%ls hrc=%Rhrc\n", this, "MachineDebugger::loadPlugIn", !RT_VALID_PTR(aPlugInName) ? 0 : *aPlugInName, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::UnloadPlugIn(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "MachineDebugger::unloadPlugIn", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_UNLOADPLUGIN_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unloadPlugIn(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_UNLOADPLUGIN_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_UNLOADPLUGIN_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_UNLOADPLUGIN_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::unloadPlugIn", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::DetectOS(BSTR *aOs)
{
    LogRelFlow(("{%p} %s: enter aOs=%p\n", this, "MachineDebugger::detectOS", aOs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOs);


        BSTROutConverter TmpOs(aOs);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DETECTOS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detectOS(TmpOs.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DETECTOS_RETURN(this, hrc, 0 /*normal*/, TmpOs.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DETECTOS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DETECTOS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aOs=%ls hrc=%Rhrc\n", this, "MachineDebugger::detectOS", !RT_VALID_PTR(aOs) ? 0 : *aOs, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::QueryOSKernelLog(ULONG aMaxMessages,
                                                   BSTR *aDmesg)
{
    LogRelFlow(("{%p} %s: enter aMaxMessages=%RU32 aDmesg=%p\n", this, "MachineDebugger::queryOSKernelLog", aMaxMessages, aDmesg));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDmesg);


        
        BSTROutConverter TmpDmesg(aDmesg);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_QUERYOSKERNELLOG_ENTER(this, aMaxMessages);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryOSKernelLog(aMaxMessages,
                                   TmpDmesg.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_QUERYOSKERNELLOG_RETURN(this, hrc, 0 /*normal*/, aMaxMessages, TmpDmesg.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_QUERYOSKERNELLOG_RETURN(this, hrc, 1 /*hrc exception*/, aMaxMessages, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_QUERYOSKERNELLOG_RETURN(this, hrc, 9 /*unhandled exception*/, aMaxMessages, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDmesg=%ls hrc=%Rhrc\n", this, "MachineDebugger::queryOSKernelLog", !RT_VALID_PTR(aDmesg) ? 0 : *aDmesg, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::GetRegister(ULONG aCpuId,
                                              IN_BSTR aName,
                                              BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aName=%ls aValue=%p\n", this, "MachineDebugger::getRegister", aCpuId, aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        
        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTER_ENTER(this, aCpuId, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRegister(aCpuId,
                              TmpName.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTER_RETURN(this, hrc, 0 /*normal*/, aCpuId, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTER_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTER_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "MachineDebugger::getRegister", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::GetRegisters(ULONG aCpuId,
                                               ComSafeArrayOut(BSTR, aNames),
                                               ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aNames=%p aValues=%p\n", this, "MachineDebugger::getRegisters", aCpuId, aNames, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNames);
        CheckComArgOutPointerValidThrow(aValues);


        
        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTERS_ENTER(this, aCpuId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRegisters(aCpuId,
                               TmpNames.array(),
                               TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTERS_RETURN(this, hrc, 0 /*normal*/, aCpuId, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTERS_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETREGISTERS_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aValues=%zu hrc=%Rhrc\n", this, "MachineDebugger::getRegisters", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::SetRegister(ULONG aCpuId,
                                              IN_BSTR aName,
                                              IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aName=%ls aValue=%ls\n", this, "MachineDebugger::setRegister", aCpuId, aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTER_ENTER(this, aCpuId, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRegister(aCpuId,
                              TmpName.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTER_RETURN(this, hrc, 0 /*normal*/, aCpuId, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTER_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTER_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setRegister", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::SetRegisters(ULONG aCpuId,
                                               ComSafeArrayIn(IN_BSTR, aNames),
                                               ComSafeArrayIn(IN_BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aNames=%zu aValues=%zu\n", this, "MachineDebugger::setRegisters", aCpuId, aNames, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        ArrayBSTRInConverter TmpNames(ComSafeArrayInArg(aNames));
        ArrayBSTRInConverter TmpValues(ComSafeArrayInArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTERS_ENTER(this, aCpuId, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRegisters(aCpuId,
                               TmpNames.array(),
                               TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTERS_RETURN(this, hrc, 0 /*normal*/, aCpuId, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTERS_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_SETREGISTERS_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setRegisters", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::DumpGuestStack(ULONG aCpuId,
                                                 BSTR *aStack)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aStack=%p\n", this, "MachineDebugger::dumpGuestStack", aCpuId, aStack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStack);


        
        BSTROutConverter TmpStack(aStack);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTSTACK_ENTER(this, aCpuId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dumpGuestStack(aCpuId,
                                 TmpStack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTSTACK_RETURN(this, hrc, 0 /*normal*/, aCpuId, TmpStack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTSTACK_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPGUESTSTACK_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aStack=%ls hrc=%Rhrc\n", this, "MachineDebugger::dumpGuestStack", !RT_VALID_PTR(aStack) ? 0 : *aStack, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::ResetStats(IN_BSTR aPattern)
{
    LogRelFlow(("{%p} %s: enter aPattern=%ls\n", this, "MachineDebugger::resetStats", aPattern));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPattern(aPattern);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_RESETSTATS_ENTER(this, TmpPattern.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resetStats(TmpPattern.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_RESETSTATS_RETURN(this, hrc, 0 /*normal*/, TmpPattern.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_RESETSTATS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_RESETSTATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::resetStats", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::DumpStats(IN_BSTR aPattern)
{
    LogRelFlow(("{%p} %s: enter aPattern=%ls\n", this, "MachineDebugger::dumpStats", aPattern));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPattern(aPattern);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPSTATS_ENTER(this, TmpPattern.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dumpStats(TmpPattern.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPSTATS_RETURN(this, hrc, 0 /*normal*/, TmpPattern.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPSTATS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_DUMPSTATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::dumpStats", hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::GetStats(IN_BSTR aPattern,
                                           BOOL aWithDescriptions,
                                           BSTR *aStats)
{
    LogRelFlow(("{%p} %s: enter aPattern=%ls aWithDescriptions=%RTbool aStats=%p\n", this, "MachineDebugger::getStats", aPattern, aWithDescriptions, aStats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStats);


        BSTRInConverter TmpPattern(aPattern);
        
        BSTROutConverter TmpStats(aStats);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETSTATS_ENTER(this, TmpPattern.str().c_str(), aWithDescriptions != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStats(TmpPattern.str(),
                           aWithDescriptions != FALSE,
                           TmpStats.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETSTATS_RETURN(this, hrc, 0 /*normal*/, TmpPattern.str().c_str(), aWithDescriptions != FALSE, TmpStats.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETSTATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aWithDescriptions != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETSTATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aWithDescriptions != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aStats=%ls hrc=%Rhrc\n", this, "MachineDebugger::getStats", !RT_VALID_PTR(aStats) ? 0 : *aStats, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::GetCPULoad(ULONG aCpuId,
                                             ULONG *aPctExecuting,
                                             ULONG *aPctHalted,
                                             ULONG *aPctOther,
                                             LONG64 *aMsInterval)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aPctExecuting=%p aPctHalted=%p aPctOther=%p aMsInterval=%p\n", this, "MachineDebugger::getCPULoad", aCpuId, aPctExecuting, aPctHalted, aPctOther, aMsInterval));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPctExecuting);
        CheckComArgOutPointerValidThrow(aPctHalted);
        CheckComArgOutPointerValidThrow(aPctOther);
        CheckComArgOutPointerValidThrow(aMsInterval);


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETCPULOAD_ENTER(this, aCpuId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPULoad(aCpuId,
                             aPctExecuting,
                             aPctHalted,
                             aPctOther,
                             aMsInterval);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETCPULOAD_RETURN(this, hrc, 0 /*normal*/, aCpuId, *aPctExecuting, *aPctHalted, *aPctOther, *aMsInterval);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETCPULOAD_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, *aPctExecuting, *aPctHalted, *aPctOther, *aMsInterval);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETCPULOAD_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, *aPctExecuting, *aPctHalted, *aPctOther, *aMsInterval);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPctExecuting=%RU32 *aPctHalted=%RU32 *aPctOther=%RU32 aMsInterval=%RI64 hrc=%Rhrc\n", this, "MachineDebugger::getCPULoad", !RT_VALID_PTR(aPctExecuting) ? 0 : *aPctExecuting, !RT_VALID_PTR(aPctHalted) ? 0 : *aPctHalted, !RT_VALID_PTR(aPctOther) ? 0 : *aPctOther, !RT_VALID_PTR(aMsInterval) ? 0 : *aMsInterval, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::TakeGuestSample(IN_BSTR aFilename,
                                                  ULONG aUsInterval,
                                                  LONG64 aUsSampleTime,
                                                  IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFilename=%ls aUsInterval=%RU32 aUsSampleTime=%RI64 aProgress=%p\n", this, "MachineDebugger::takeGuestSample", aFilename, aUsInterval, aUsSampleTime, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFilename(aFilename);
        
        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_TAKEGUESTSAMPLE_ENTER(this, TmpFilename.str().c_str(), aUsInterval, aUsSampleTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = takeGuestSample(TmpFilename.str(),
                                  aUsInterval,
                                  aUsSampleTime,
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_TAKEGUESTSAMPLE_RETURN(this, hrc, 0 /*normal*/, TmpFilename.str().c_str(), aUsInterval, aUsSampleTime, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_TAKEGUESTSAMPLE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aUsInterval, aUsSampleTime, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_TAKEGUESTSAMPLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aUsInterval, aUsSampleTime, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "MachineDebugger::takeGuestSample", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::GetUVMAndVMMFunctionTable(LONG64 aMagicVersion,
                                                            LONG64 *aVMMFunctionTable,
                                                            LONG64 *aUVM)
{
    LogRelFlow(("{%p} %s: enter aMagicVersion=%RI64 aVMMFunctionTable=%p aUVM=%p\n", this, "MachineDebugger::getUVMAndVMMFunctionTable", aMagicVersion, aVMMFunctionTable, aUVM));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVMMFunctionTable);
        CheckComArgOutPointerValidThrow(aUVM);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETUVMANDVMMFUNCTIONTABLE_ENTER(this, aMagicVersion);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUVMAndVMMFunctionTable(aMagicVersion,
                                            aVMMFunctionTable,
                                            aUVM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETUVMANDVMMFUNCTIONTABLE_RETURN(this, hrc, 0 /*normal*/, aMagicVersion, *aVMMFunctionTable, *aUVM);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETUVMANDVMMFUNCTIONTABLE_RETURN(this, hrc, 1 /*hrc exception*/, aMagicVersion, *aVMMFunctionTable, *aUVM);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEDEBUGGER_GETUVMANDVMMFUNCTIONTABLE_RETURN(this, hrc, 9 /*unhandled exception*/, aMagicVersion, *aVMMFunctionTable, *aUVM);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVMMFunctionTable=%RI64 aUVM=%RI64 hrc=%Rhrc\n", this, "MachineDebugger::getUVMAndVMMFunctionTable", !RT_VALID_PTR(aVMMFunctionTable) ? 0 : *aVMMFunctionTable, !RT_VALID_PTR(aUVM) ? 0 : *aUVM, hrc));
    return hrc;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod1IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod2IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod3IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod4IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod5IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod6IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod7IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod8IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod9IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod10IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod11IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod12IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod13IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod14IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod15IMachineDebugger()
{
    return E_NOTIMPL;
}

STDMETHODIMP MachineDebuggerWrap::InternalAndReservedMethod16IMachineDebugger()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MachineDebuggerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MachineDebuggerWrap, IMachineDebugger)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MachineDebuggerWrap.cpp"


// ##### BEGINFILE "USBDeviceFilterWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUSBDeviceFilter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_USBDEVICEFILTER

#include "USBDeviceFilterWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(USBDeviceFilterWrap)

//
// IUSBDeviceFilter properties
//

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "USBDeviceFilter::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "USBDeviceFilter::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setName", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Active)(BOOL *aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%p\n", this, "USBDeviceFilter::getActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aActive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_ACTIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getActive(aActive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,*aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aActive=%RTbool hrc=%Rhrc\n", this, "USBDeviceFilter::getActive", !RT_VALID_PTR(aActive) ? 0 : *aActive, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Active)(BOOL aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%RTbool\n", this, "USBDeviceFilter::setActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_ACTIVE_ENTER(this, aActive != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setActive(aActive != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setActive", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(VendorId)(BSTR *aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%p\n", this, "USBDeviceFilter::getVendorId", aVendorId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVendorId);
        BSTROutConverter TmpVendorId(aVendorId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_VENDORID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVendorId(TmpVendorId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 0 /*normal*/,TmpVendorId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVendorId=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getVendorId", !RT_VALID_PTR(aVendorId) ? 0 : *aVendorId, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(VendorId)(IN_BSTR aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%ls\n", this, "USBDeviceFilter::setVendorId", aVendorId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpVendorId(aVendorId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_VENDORID_ENTER(this, TmpVendorId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVendorId(TmpVendorId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 0 /*normal*/,TmpVendorId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setVendorId", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(ProductId)(BSTR *aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%p\n", this, "USBDeviceFilter::getProductId", aProductId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProductId);
        BSTROutConverter TmpProductId(aProductId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCTID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProductId(TmpProductId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,TmpProductId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProductId=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getProductId", !RT_VALID_PTR(aProductId) ? 0 : *aProductId, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(ProductId)(IN_BSTR aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%ls\n", this, "USBDeviceFilter::setProductId", aProductId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProductId(aProductId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCTID_ENTER(this, TmpProductId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProductId(TmpProductId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,TmpProductId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setProductId", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Revision)(BSTR *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "USBDeviceFilter::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        BSTROutConverter TmpRevision(aRevision);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(TmpRevision.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,TmpRevision.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Revision)(IN_BSTR aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%ls\n", this, "USBDeviceFilter::setRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpRevision(aRevision);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REVISION_ENTER(this, TmpRevision.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRevision(TmpRevision.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 0 /*normal*/,TmpRevision.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setRevision", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Manufacturer)(BSTR *aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%p\n", this, "USBDeviceFilter::getManufacturer", aManufacturer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aManufacturer);
        BSTROutConverter TmpManufacturer(aManufacturer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MANUFACTURER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getManufacturer(TmpManufacturer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aManufacturer=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getManufacturer", !RT_VALID_PTR(aManufacturer) ? 0 : *aManufacturer, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Manufacturer)(IN_BSTR aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%ls\n", this, "USBDeviceFilter::setManufacturer", aManufacturer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpManufacturer(aManufacturer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MANUFACTURER_ENTER(this, TmpManufacturer.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setManufacturer(TmpManufacturer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setManufacturer", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Product)(BSTR *aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%p\n", this, "USBDeviceFilter::getProduct", aProduct));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProduct);
        BSTROutConverter TmpProduct(aProduct);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProduct(TmpProduct.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProduct=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getProduct", !RT_VALID_PTR(aProduct) ? 0 : *aProduct, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Product)(IN_BSTR aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%ls\n", this, "USBDeviceFilter::setProduct", aProduct));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProduct(aProduct);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCT_ENTER(this, TmpProduct.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProduct(TmpProduct.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setProduct", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "USBDeviceFilter::getSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialNumber);
        BSTROutConverter TmpSerialNumber(aSerialNumber);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(SerialNumber)(IN_BSTR aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%ls\n", this, "USBDeviceFilter::setSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpSerialNumber(aSerialNumber);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_SERIALNUMBER_ENTER(this, TmpSerialNumber.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setSerialNumber", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Port)(BSTR *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "USBDeviceFilter::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        BSTROutConverter TmpPort(aPort);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(TmpPort.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 0 /*normal*/,TmpPort.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Port)(IN_BSTR aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%ls\n", this, "USBDeviceFilter::setPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpPort(aPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PORT_ENTER(this, TmpPort.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPort(TmpPort.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 0 /*normal*/,TmpPort.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setPort", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(Remote)(BSTR *aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%p\n", this, "USBDeviceFilter::getRemote", aRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemote);
        BSTROutConverter TmpRemote(aRemote);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemote(TmpRemote.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 0 /*normal*/,TmpRemote.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemote=%ls hrc=%Rhrc\n", this, "USBDeviceFilter::getRemote", !RT_VALID_PTR(aRemote) ? 0 : *aRemote, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(Remote)(IN_BSTR aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%ls\n", this, "USBDeviceFilter::setRemote", aRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpRemote(aRemote);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REMOTE_ENTER(this, TmpRemote.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRemote(TmpRemote.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 0 /*normal*/,TmpRemote.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setRemote", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(MaskedInterfaces)(ULONG *aMaskedInterfaces)
{
    LogRelFlow(("{%p} %s: enter aMaskedInterfaces=%p\n", this, "USBDeviceFilter::getMaskedInterfaces", aMaskedInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaskedInterfaces);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MASKEDINTERFACES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaskedInterfaces(aMaskedInterfaces);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 0 /*normal*/,*aMaskedInterfaces);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 1 /*hrc exception*/,*aMaskedInterfaces);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaskedInterfaces);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaskedInterfaces=%RU32 hrc=%Rhrc\n", this, "USBDeviceFilter::getMaskedInterfaces", !RT_VALID_PTR(aMaskedInterfaces) ? 0 : *aMaskedInterfaces, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMSETTER(MaskedInterfaces)(ULONG aMaskedInterfaces)
{
    LogRelFlow(("{%p} %s: enter aMaskedInterfaces=%RU32\n", this, "USBDeviceFilter::setMaskedInterfaces", aMaskedInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MASKEDINTERFACES_ENTER(this, aMaskedInterfaces);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaskedInterfaces(aMaskedInterfaces);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 0 /*normal*/,aMaskedInterfaces);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 1 /*hrc exception*/,aMaskedInterfaces);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 9 /*unhandled exception*/,aMaskedInterfaces);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilter::setMaskedInterfaces", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBDeviceFilter methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(USBDeviceFilterWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBDeviceFilterWrap, IUSBDeviceFilter)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "USBDeviceFilterWrap.cpp"


// ##### BEGINFILE "HostUSBDeviceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostUSBDevice.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTUSBDEVICE

#include "HostUSBDeviceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostUSBDeviceWrap)

//
// IUSBDevice properties
//

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "HostUSBDevice::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(VendorId)(USHORT *aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%p\n", this, "HostUSBDevice::getVendorId", aVendorId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVendorId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VENDORID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVendorId(aVendorId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VENDORID_RETURN(this, hrc, 0 /*normal*/,*aVendorId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VENDORID_RETURN(this, hrc, 1 /*hrc exception*/,*aVendorId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,*aVendorId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVendorId=%RU16 hrc=%Rhrc\n", this, "HostUSBDevice::getVendorId", !RT_VALID_PTR(aVendorId) ? 0 : *aVendorId, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(ProductId)(USHORT *aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%p\n", this, "HostUSBDevice::getProductId", aProductId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProductId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCTID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProductId(aProductId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,*aProductId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCTID_RETURN(this, hrc, 1 /*hrc exception*/,*aProductId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,*aProductId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProductId=%RU16 hrc=%Rhrc\n", this, "HostUSBDevice::getProductId", !RT_VALID_PTR(aProductId) ? 0 : *aProductId, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Revision)(USHORT *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "HostUSBDevice::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU16 hrc=%Rhrc\n", this, "HostUSBDevice::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Manufacturer)(BSTR *aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%p\n", this, "HostUSBDevice::getManufacturer", aManufacturer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aManufacturer);
        BSTROutConverter TmpManufacturer(aManufacturer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_MANUFACTURER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getManufacturer(TmpManufacturer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_MANUFACTURER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aManufacturer=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getManufacturer", !RT_VALID_PTR(aManufacturer) ? 0 : *aManufacturer, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Product)(BSTR *aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%p\n", this, "HostUSBDevice::getProduct", aProduct));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProduct);
        BSTROutConverter TmpProduct(aProduct);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProduct(TmpProduct.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProduct=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getProduct", !RT_VALID_PTR(aProduct) ? 0 : *aProduct, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "HostUSBDevice::getSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialNumber);
        BSTROutConverter TmpSerialNumber(aSerialNumber);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Address)(BSTR *aAddress)
{
    LogRelFlow(("{%p} %s: enter aAddress=%p\n", this, "HostUSBDevice::getAddress", aAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAddress);
        BSTROutConverter TmpAddress(aAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAddress(TmpAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_ADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAddress=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getAddress", !RT_VALID_PTR(aAddress) ? 0 : *aAddress, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Port)(USHORT *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "HostUSBDevice::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(aPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORT_RETURN(this, hrc, 0 /*normal*/,*aPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,*aPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%RU16 hrc=%Rhrc\n", this, "HostUSBDevice::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(PortPath)(BSTR *aPortPath)
{
    LogRelFlow(("{%p} %s: enter aPortPath=%p\n", this, "HostUSBDevice::getPortPath", aPortPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPortPath);
        BSTROutConverter TmpPortPath(aPortPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORTPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPortPath(TmpPortPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORTPATH_RETURN(this, hrc, 0 /*normal*/,TmpPortPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORTPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_PORTPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPortPath=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getPortPath", !RT_VALID_PTR(aPortPath) ? 0 : *aPortPath, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Version)(USHORT *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "HostUSBDevice::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(aVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,*aVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%RU16 hrc=%Rhrc\n", this, "HostUSBDevice::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Speed)(USBConnectionSpeed_T *aSpeed)
{
    LogRelFlow(("{%p} %s: enter aSpeed=%p\n", this, "HostUSBDevice::getSpeed", aSpeed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSpeed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SPEED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSpeed(aSpeed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SPEED_RETURN(this, hrc, 0 /*normal*/,*aSpeed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SPEED_RETURN(this, hrc, 1 /*hrc exception*/,*aSpeed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_SPEED_RETURN(this, hrc, 9 /*unhandled exception*/,*aSpeed);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSpeed=%RU32 hrc=%Rhrc\n", this, "HostUSBDevice::getSpeed", !RT_VALID_PTR(aSpeed) ? 0 : *aSpeed, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Remote)(BOOL *aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%p\n", this, "HostUSBDevice::getRemote", aRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemote);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemote(aRemote);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REMOTE_RETURN(this, hrc, 0 /*normal*/,*aRemote != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REMOTE_RETURN(this, hrc, 1 /*hrc exception*/,*aRemote != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRemote != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemote=%RTbool hrc=%Rhrc\n", this, "HostUSBDevice::getRemote", !RT_VALID_PTR(aRemote) ? 0 : *aRemote, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(DeviceInfo)(ComSafeArrayOut(BSTR, aDeviceInfo))
{
    LogRelFlow(("{%p} %s: enter aDeviceInfo=%p\n", this, "HostUSBDevice::getDeviceInfo", aDeviceInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceInfo);
        ArrayBSTROutConverter TmpDeviceInfo(ComSafeArrayOutArg(aDeviceInfo));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_DEVICEINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceInfo(TmpDeviceInfo.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_DEVICEINFO_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDeviceInfo.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_DEVICEINFO_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_DEVICEINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceInfo=%zu hrc=%Rhrc\n", this, "HostUSBDevice::getDeviceInfo", !RT_VALID_PTR(aDeviceInfo) ? 0 : ComSafeArraySize(*aDeviceInfo), hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(Backend)(BSTR *aBackend)
{
    LogRelFlow(("{%p} %s: enter aBackend=%p\n", this, "HostUSBDevice::getBackend", aBackend));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBackend);
        BSTROutConverter TmpBackend(aBackend);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_BACKEND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBackend(TmpBackend.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_BACKEND_RETURN(this, hrc, 0 /*normal*/,TmpBackend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_BACKEND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_BACKEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBackend=%ls hrc=%Rhrc\n", this, "HostUSBDevice::getBackend", !RT_VALID_PTR(aBackend) ? 0 : *aBackend, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute1IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute2IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute3IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute4IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IHostUSBDevice properties
//

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(State)(USBDeviceState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "HostUSBDevice::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICE_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "HostUSBDevice::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute1IHostUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute2IHostUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute3IHostUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceWrap::COMGETTER(InternalAndReservedAttribute4IHostUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBDevice methods
//

//
// IHostUSBDevice methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostUSBDeviceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HostUSBDeviceWrap, IHostUSBDevice, IUSBDevice)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostUSBDeviceWrap.cpp"


// ##### BEGINFILE "HostUSBDeviceFilterWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostUSBDeviceFilter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTUSBDEVICEFILTER

#include "HostUSBDeviceFilterWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostUSBDeviceFilterWrap)

//
// IUSBDeviceFilter properties
//

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostUSBDeviceFilter::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "HostUSBDeviceFilter::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setName", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Active)(BOOL *aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%p\n", this, "HostUSBDeviceFilter::getActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aActive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getActive(aActive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,*aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aActive=%RTbool hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getActive", !RT_VALID_PTR(aActive) ? 0 : *aActive, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Active)(BOOL aActive)
{
    LogRelFlow(("{%p} %s: enter aActive=%RTbool\n", this, "HostUSBDeviceFilter::setActive", aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTIVE_ENTER(this, aActive != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setActive(aActive != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 0 /*normal*/,aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 1 /*hrc exception*/,aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTIVE_RETURN(this, hrc, 9 /*unhandled exception*/,aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setActive", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(VendorId)(BSTR *aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%p\n", this, "HostUSBDeviceFilter::getVendorId", aVendorId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVendorId);
        BSTROutConverter TmpVendorId(aVendorId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_VENDORID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVendorId(TmpVendorId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 0 /*normal*/,TmpVendorId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVendorId=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getVendorId", !RT_VALID_PTR(aVendorId) ? 0 : *aVendorId, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(VendorId)(IN_BSTR aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%ls\n", this, "HostUSBDeviceFilter::setVendorId", aVendorId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpVendorId(aVendorId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_VENDORID_ENTER(this, TmpVendorId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVendorId(TmpVendorId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 0 /*normal*/,TmpVendorId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setVendorId", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(ProductId)(BSTR *aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%p\n", this, "HostUSBDeviceFilter::getProductId", aProductId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProductId);
        BSTROutConverter TmpProductId(aProductId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCTID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProductId(TmpProductId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,TmpProductId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProductId=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getProductId", !RT_VALID_PTR(aProductId) ? 0 : *aProductId, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(ProductId)(IN_BSTR aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%ls\n", this, "HostUSBDeviceFilter::setProductId", aProductId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProductId(aProductId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCTID_ENTER(this, TmpProductId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProductId(TmpProductId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,TmpProductId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setProductId", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Revision)(BSTR *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "HostUSBDeviceFilter::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        BSTROutConverter TmpRevision(aRevision);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(TmpRevision.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,TmpRevision.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Revision)(IN_BSTR aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%ls\n", this, "HostUSBDeviceFilter::setRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpRevision(aRevision);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REVISION_ENTER(this, TmpRevision.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRevision(TmpRevision.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 0 /*normal*/,TmpRevision.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setRevision", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Manufacturer)(BSTR *aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%p\n", this, "HostUSBDeviceFilter::getManufacturer", aManufacturer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aManufacturer);
        BSTROutConverter TmpManufacturer(aManufacturer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MANUFACTURER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getManufacturer(TmpManufacturer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aManufacturer=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getManufacturer", !RT_VALID_PTR(aManufacturer) ? 0 : *aManufacturer, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Manufacturer)(IN_BSTR aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%ls\n", this, "HostUSBDeviceFilter::setManufacturer", aManufacturer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpManufacturer(aManufacturer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MANUFACTURER_ENTER(this, TmpManufacturer.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setManufacturer(TmpManufacturer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setManufacturer", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Product)(BSTR *aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%p\n", this, "HostUSBDeviceFilter::getProduct", aProduct));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProduct);
        BSTROutConverter TmpProduct(aProduct);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProduct(TmpProduct.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProduct=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getProduct", !RT_VALID_PTR(aProduct) ? 0 : *aProduct, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Product)(IN_BSTR aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%ls\n", this, "HostUSBDeviceFilter::setProduct", aProduct));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpProduct(aProduct);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCT_ENTER(this, TmpProduct.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProduct(TmpProduct.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setProduct", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "HostUSBDeviceFilter::getSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialNumber);
        BSTROutConverter TmpSerialNumber(aSerialNumber);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(SerialNumber)(IN_BSTR aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%ls\n", this, "HostUSBDeviceFilter::setSerialNumber", aSerialNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpSerialNumber(aSerialNumber);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_SERIALNUMBER_ENTER(this, TmpSerialNumber.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSerialNumber(TmpSerialNumber.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setSerialNumber", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Port)(BSTR *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "HostUSBDeviceFilter::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        BSTROutConverter TmpPort(aPort);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(TmpPort.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 0 /*normal*/,TmpPort.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Port)(IN_BSTR aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%ls\n", this, "HostUSBDeviceFilter::setPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpPort(aPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PORT_ENTER(this, TmpPort.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPort(TmpPort.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 0 /*normal*/,TmpPort.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setPort", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Remote)(BSTR *aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%p\n", this, "HostUSBDeviceFilter::getRemote", aRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemote);
        BSTROutConverter TmpRemote(aRemote);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemote(TmpRemote.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 0 /*normal*/,TmpRemote.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemote=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getRemote", !RT_VALID_PTR(aRemote) ? 0 : *aRemote, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Remote)(IN_BSTR aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%ls\n", this, "HostUSBDeviceFilter::setRemote", aRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpRemote(aRemote);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REMOTE_ENTER(this, TmpRemote.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setRemote(TmpRemote.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 0 /*normal*/,TmpRemote.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setRemote", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(MaskedInterfaces)(ULONG *aMaskedInterfaces)
{
    LogRelFlow(("{%p} %s: enter aMaskedInterfaces=%p\n", this, "HostUSBDeviceFilter::getMaskedInterfaces", aMaskedInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaskedInterfaces);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MASKEDINTERFACES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaskedInterfaces(aMaskedInterfaces);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 0 /*normal*/,*aMaskedInterfaces);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 1 /*hrc exception*/,*aMaskedInterfaces);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_MASKEDINTERFACES_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaskedInterfaces);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaskedInterfaces=%RU32 hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getMaskedInterfaces", !RT_VALID_PTR(aMaskedInterfaces) ? 0 : *aMaskedInterfaces, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(MaskedInterfaces)(ULONG aMaskedInterfaces)
{
    LogRelFlow(("{%p} %s: enter aMaskedInterfaces=%RU32\n", this, "HostUSBDeviceFilter::setMaskedInterfaces", aMaskedInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MASKEDINTERFACES_ENTER(this, aMaskedInterfaces);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaskedInterfaces(aMaskedInterfaces);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 0 /*normal*/,aMaskedInterfaces);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 1 /*hrc exception*/,aMaskedInterfaces);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_MASKEDINTERFACES_RETURN(this, hrc, 9 /*unhandled exception*/,aMaskedInterfaces);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setMaskedInterfaces", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IHostUSBDeviceFilter properties
//

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Action)(USBDeviceFilterAction_T *aAction)
{
    LogRelFlow(("{%p} %s: enter aAction=%p\n", this, "HostUSBDeviceFilter::getAction", aAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAction);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAction(aAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTION_RETURN(this, hrc, 0 /*normal*/,*aAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTION_RETURN(this, hrc, 1 /*hrc exception*/,*aAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_GET_ACTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAction=%RU32 hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getAction", !RT_VALID_PTR(aAction) ? 0 : *aAction, hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(Action)(USBDeviceFilterAction_T aAction)
{
    LogRelFlow(("{%p} %s: enter aAction=%RU32\n", this, "HostUSBDeviceFilter::setAction", aAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTION_ENTER(this, aAction);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAction(aAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTION_RETURN(this, hrc, 0 /*normal*/,aAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTION_RETURN(this, hrc, 1 /*hrc exception*/,aAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUSBDEVICEFILTER_SET_ACTION_RETURN(this, hrc, 9 /*unhandled exception*/,aAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setAction", hrc));
    return hrc;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute1IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute2IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute3IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute4IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute5IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute6IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute7IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(InternalAndReservedAttribute8IHostUSBDeviceFilter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBDeviceFilter methods
//

//
// IHostUSBDeviceFilter methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostUSBDeviceFilterWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HostUSBDeviceFilterWrap, IHostUSBDeviceFilter, IUSBDeviceFilter)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostUSBDeviceFilterWrap.cpp"


// ##### BEGINFILE "AudioSettingsWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IAudioSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_AUDIOSETTINGS

#include "AudioSettingsWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(AudioSettingsWrap)

//
// IAudioSettings properties
//

STDMETHODIMP AudioSettingsWrap::COMGETTER(Adapter)(IAudioAdapter **aAdapter)
{
    LogRelFlow(("{%p} %s: enter aAdapter=%p\n", this, "AudioSettings::getAdapter", aAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdapter);
        ComTypeOutConverter<IAudioAdapter> TmpAdapter(aAdapter);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GET_ADAPTER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdapter(TmpAdapter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GET_ADAPTER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpAdapter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GET_ADAPTER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GET_ADAPTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdapter=%p hrc=%Rhrc\n", this, "AudioSettings::getAdapter", !RT_VALID_PTR(aAdapter) ? 0 : *aAdapter, hrc));
    return hrc;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute1IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute2IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute3IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute4IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute5IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute6IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute7IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::COMGETTER(InternalAndReservedAttribute8IAudioSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IAudioSettings methods
//

STDMETHODIMP AudioSettingsWrap::GetHostAudioDevice(AudioDirection_T aUsage,
                                                   IHostAudioDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aUsage=%RU32 aDevice=%p\n", this, "AudioSettings::getHostAudioDevice", aUsage, aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDevice);


        
        ComTypeOutConverter<IHostAudioDevice> TmpDevice(aDevice);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GETHOSTAUDIODEVICE_ENTER(this, aUsage);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostAudioDevice(aUsage,
                                     TmpDevice.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GETHOSTAUDIODEVICE_RETURN(this, hrc, 0 /*normal*/, aUsage, (void *)TmpDevice.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GETHOSTAUDIODEVICE_RETURN(this, hrc, 1 /*hrc exception*/, aUsage, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_GETHOSTAUDIODEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, aUsage, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDevice=%p hrc=%Rhrc\n", this, "AudioSettings::getHostAudioDevice", !RT_VALID_PTR(aDevice) ? 0 : *aDevice, hrc));
    return hrc;
}

STDMETHODIMP AudioSettingsWrap::SetHostAudioDevice(IHostAudioDevice *aDevice,
                                                   AudioDirection_T aUsage)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p aUsage=%RU32\n", this, "AudioSettings::setHostAudioDevice", aDevice, aUsage));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IHostAudioDevice> TmpDevice(aDevice);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_SETHOSTAUDIODEVICE_ENTER(this, (void *)TmpDevice.ptr(), aUsage);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostAudioDevice(TmpDevice.ptr(),
                                     aUsage);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_SETHOSTAUDIODEVICE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDevice.ptr(), aUsage);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_SETHOSTAUDIODEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aUsage);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOSETTINGS_SETHOSTAUDIODEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aUsage);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioSettings::setHostAudioDevice", hrc));
    return hrc;
}

STDMETHODIMP AudioSettingsWrap::InternalAndReservedMethod1IAudioSettings()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::InternalAndReservedMethod2IAudioSettings()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::InternalAndReservedMethod3IAudioSettings()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioSettingsWrap::InternalAndReservedMethod4IAudioSettings()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(AudioSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AudioSettingsWrap, IAudioSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "AudioSettingsWrap.cpp"


// ##### BEGINFILE "VRDEServerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVRDEServer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VRDESERVER

#include "VRDEServerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VRDEServerWrap)

//
// IVRDEServer properties
//

STDMETHODIMP VRDEServerWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "VRDEServer::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "VRDEServer::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthType)(AuthType_T *aAuthType)
{
    LogRelFlow(("{%p} %s: enter aAuthType=%p\n", this, "VRDEServer::getAuthType", aAuthType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthType(aAuthType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 0 /*normal*/,*aAuthType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAuthType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAuthType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthType=%RU32 hrc=%Rhrc\n", this, "VRDEServer::getAuthType", !RT_VALID_PTR(aAuthType) ? 0 : *aAuthType, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthType)(AuthType_T aAuthType)
{
    LogRelFlow(("{%p} %s: enter aAuthType=%RU32\n", this, "VRDEServer::setAuthType", aAuthType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_ENTER(this, aAuthType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthType(aAuthType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 0 /*normal*/,aAuthType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aAuthType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aAuthType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthType", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthTimeout)(ULONG *aAuthTimeout)
{
    LogRelFlow(("{%p} %s: enter aAuthTimeout=%p\n", this, "VRDEServer::getAuthTimeout", aAuthTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthTimeout(aAuthTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aAuthTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aAuthTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aAuthTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthTimeout=%RU32 hrc=%Rhrc\n", this, "VRDEServer::getAuthTimeout", !RT_VALID_PTR(aAuthTimeout) ? 0 : *aAuthTimeout, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthTimeout)(ULONG aAuthTimeout)
{
    LogRelFlow(("{%p} %s: enter aAuthTimeout=%RU32\n", this, "VRDEServer::setAuthTimeout", aAuthTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_ENTER(this, aAuthTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthTimeout(aAuthTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 0 /*normal*/,aAuthTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aAuthTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aAuthTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthTimeout", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AllowMultiConnection)(BOOL *aAllowMultiConnection)
{
    LogRelFlow(("{%p} %s: enter aAllowMultiConnection=%p\n", this, "VRDEServer::getAllowMultiConnection", aAllowMultiConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllowMultiConnection);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllowMultiConnection(aAllowMultiConnection);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 0 /*normal*/,*aAllowMultiConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,*aAllowMultiConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllowMultiConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllowMultiConnection=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getAllowMultiConnection", !RT_VALID_PTR(aAllowMultiConnection) ? 0 : *aAllowMultiConnection, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AllowMultiConnection)(BOOL aAllowMultiConnection)
{
    LogRelFlow(("{%p} %s: enter aAllowMultiConnection=%RTbool\n", this, "VRDEServer::setAllowMultiConnection", aAllowMultiConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_ENTER(this, aAllowMultiConnection != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAllowMultiConnection(aAllowMultiConnection != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 0 /*normal*/,aAllowMultiConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,aAllowMultiConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,aAllowMultiConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAllowMultiConnection", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(ReuseSingleConnection)(BOOL *aReuseSingleConnection)
{
    LogRelFlow(("{%p} %s: enter aReuseSingleConnection=%p\n", this, "VRDEServer::getReuseSingleConnection", aReuseSingleConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReuseSingleConnection);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReuseSingleConnection(aReuseSingleConnection);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 0 /*normal*/,*aReuseSingleConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,*aReuseSingleConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aReuseSingleConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReuseSingleConnection=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getReuseSingleConnection", !RT_VALID_PTR(aReuseSingleConnection) ? 0 : *aReuseSingleConnection, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(ReuseSingleConnection)(BOOL aReuseSingleConnection)
{
    LogRelFlow(("{%p} %s: enter aReuseSingleConnection=%RTbool\n", this, "VRDEServer::setReuseSingleConnection", aReuseSingleConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_ENTER(this, aReuseSingleConnection != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setReuseSingleConnection(aReuseSingleConnection != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 0 /*normal*/,aReuseSingleConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,aReuseSingleConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,aReuseSingleConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setReuseSingleConnection", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(VRDEExtPack)(BSTR *aVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aVRDEExtPack=%p\n", this, "VRDEServer::getVRDEExtPack", aVRDEExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEExtPack);
        BSTROutConverter TmpVRDEExtPack(aVRDEExtPack);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEExtPack(TmpVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEExtPack=%ls hrc=%Rhrc\n", this, "VRDEServer::getVRDEExtPack", !RT_VALID_PTR(aVRDEExtPack) ? 0 : *aVRDEExtPack, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(VRDEExtPack)(IN_BSTR aVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aVRDEExtPack=%ls\n", this, "VRDEServer::setVRDEExtPack", aVRDEExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpVRDEExtPack(aVRDEExtPack);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_ENTER(this, TmpVRDEExtPack.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRDEExtPack(TmpVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setVRDEExtPack", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthLibrary)(BSTR *aAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aAuthLibrary=%p\n", this, "VRDEServer::getAuthLibrary", aAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthLibrary);
        BSTROutConverter TmpAuthLibrary(aAuthLibrary);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthLibrary(TmpAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthLibrary=%ls hrc=%Rhrc\n", this, "VRDEServer::getAuthLibrary", !RT_VALID_PTR(aAuthLibrary) ? 0 : *aAuthLibrary, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthLibrary)(IN_BSTR aAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aAuthLibrary=%ls\n", this, "VRDEServer::setAuthLibrary", aAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpAuthLibrary(aAuthLibrary);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_ENTER(this, TmpAuthLibrary.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthLibrary(TmpAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthLibrary", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(VRDEProperties)(ComSafeArrayOut(BSTR, aVRDEProperties))
{
    LogRelFlow(("{%p} %s: enter aVRDEProperties=%p\n", this, "VRDEServer::getVRDEProperties", aVRDEProperties));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEProperties);
        ArrayBSTROutConverter TmpVRDEProperties(ComSafeArrayOutArg(aVRDEProperties));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEProperties(TmpVRDEProperties.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpVRDEProperties.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEProperties=%zu hrc=%Rhrc\n", this, "VRDEServer::getVRDEProperties", !RT_VALID_PTR(aVRDEProperties) ? 0 : ComSafeArraySize(*aVRDEProperties), hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute1IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute2IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute3IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute4IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVRDEServer methods
//

STDMETHODIMP VRDEServerWrap::SetVRDEProperty(IN_BSTR aKey,
                                             IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%ls\n", this, "VRDEServer::setVRDEProperty", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpKey(aKey);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRDEProperty(TmpKey.str(),
                                  TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setVRDEProperty", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::GetVRDEProperty(IN_BSTR aKey,
                                             BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "VRDEServer::getVRDEProperty", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpKey(aKey);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEProperty(TmpKey.str(),
                                  TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "VRDEServer::getVRDEProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::InternalAndReservedMethod1IVRDEServer()
{
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::InternalAndReservedMethod2IVRDEServer()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VRDEServerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VRDEServerWrap, IVRDEServer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VRDEServerWrap.cpp"


// ##### BEGINFILE "SessionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_SESSION

#include "SessionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SessionWrap)

//
// ISession properties
//

STDMETHODIMP SessionWrap::COMGETTER(State)(SessionState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Session::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "Session::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Type)(SessionType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "Session::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "Session::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Session::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Session::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Session::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::setName", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Session::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "Session::getMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Console)(IConsole **aConsole)
{
    LogRelFlow(("{%p} %s: enter aConsole=%p\n", this, "Session::getConsole", aConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConsole);
        ComTypeOutConverter<IConsole> TmpConsole(aConsole);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConsole(TmpConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aConsole=%p hrc=%Rhrc\n", this, "Session::getConsole", !RT_VALID_PTR(aConsole) ? 0 : *aConsole, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute1ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute2ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute3ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute4ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute5ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute6ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute7ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute8ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IInternalSessionControl properties
//

STDMETHODIMP SessionWrap::COMGETTER(PID)(ULONG *aPID)
{
    LogRelFlow(("{%p} %s: enter aPID=%p\n", this, "Session::getPID", aPID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPID(aPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 1 /*hrc exception*/,*aPID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPID=%RU32 hrc=%Rhrc\n", this, "Session::getPID", !RT_VALID_PTR(aPID) ? 0 : *aPID, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(RemoteConsole)(IConsole **aRemoteConsole)
{
    LogRelFlow(("{%p} %s: enter aRemoteConsole=%p\n", this, "Session::getRemoteConsole", aRemoteConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemoteConsole);
        ComTypeOutConverter<IConsole> TmpRemoteConsole(aRemoteConsole);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemoteConsole(TmpRemoteConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpRemoteConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemoteConsole=%p hrc=%Rhrc\n", this, "Session::getRemoteConsole", !RT_VALID_PTR(aRemoteConsole) ? 0 : *aRemoteConsole, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(NominalState)(MachineState_T *aNominalState)
{
    LogRelFlow(("{%p} %s: enter aNominalState=%p\n", this, "Session::getNominalState", aNominalState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNominalState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNominalState(aNominalState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 0 /*normal*/,*aNominalState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 1 /*hrc exception*/,*aNominalState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aNominalState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNominalState=%RU32 hrc=%Rhrc\n", this, "Session::getNominalState", !RT_VALID_PTR(aNominalState) ? 0 : *aNominalState, hrc));
    return hrc;
}


//
// ISession methods
//

STDMETHODIMP SessionWrap::UnlockMachine()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Session::unlockMachine"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unlockMachine();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::unlockMachine", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod1ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod2ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod3ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod4ISession()
{
    return E_NOTIMPL;
}

//
// IInternalSessionControl methods
//

#ifndef VBOX_WITH_XPCOM
STDMETHODIMP SessionWrap::AssignMachine(IMachine *aMachine,
                                        LockType_T aLockType,
                                        IN_BSTR aTokenId)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p aLockType=%RU32 aTokenId=%ls\n", this, "Session::assignMachine", aMachine, aLockType, aTokenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        
        BSTRInConverter TmpTokenId(aTokenId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_ENTER(this, (void *)TmpMachine.ptr(), aLockType, TmpTokenId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignMachine(TmpMachine.ptr(),
                                aLockType,
                                TmpTokenId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), aLockType, TmpTokenId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLockType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLockType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignMachine", hrc));
    return hrc;
}
#endif /* !VBOX_WITH_XPCOM */

#ifdef VBOX_WITH_XPCOM
STDMETHODIMP SessionWrap::AssignMachine(IMachine *aMachine,
                                        LockType_T aLockType,
                                        IToken *aToken)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p aLockType=%RU32 aToken=%p\n", this, "Session::assignMachine", aMachine, aLockType, aToken));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        
        ComTypeInConverter<IToken> TmpToken(aToken);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_ENTER(this, (void *)TmpMachine.ptr(), aLockType, (void *)TmpToken.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignMachine(TmpMachine.ptr(),
                                aLockType,
                                TmpToken.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), aLockType, (void *)TmpToken.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLockType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLockType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignMachine", hrc));
    return hrc;
}
#endif /* VBOX_WITH_XPCOM */

STDMETHODIMP SessionWrap::AssignRemoteMachine(IMachine *aMachine,
                                              IConsole *aConsole)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p aConsole=%p\n", this, "Session::assignRemoteMachine", aMachine, aConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        ComTypeInConverter<IConsole> TmpConsole(aConsole);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_ENTER(this, (void *)TmpMachine.ptr(), (void *)TmpConsole.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignRemoteMachine(TmpMachine.ptr(),
                                      TmpConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), (void *)TmpConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignRemoteMachine", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::UpdateMachineState(MachineState_T aMachineState)
{
    LogRelFlow(("{%p} %s: enter aMachineState=%RU32\n", this, "Session::updateMachineState", aMachineState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_ENTER(this, aMachineState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = updateMachineState(aMachineState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 0 /*normal*/, aMachineState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 1 /*hrc exception*/, aMachineState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 9 /*unhandled exception*/, aMachineState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::updateMachineState", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::Uninitialize()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Session::uninitialize"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = uninitialize();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::uninitialize", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnNetworkAdapterChange(INetworkAdapter *aNetworkAdapter,
                                                 BOOL aChangeAdapter)
{
    LogRelFlow(("{%p} %s: enter aNetworkAdapter=%p aChangeAdapter=%RTbool\n", this, "Session::onNetworkAdapterChange", aNetworkAdapter, aChangeAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<INetworkAdapter> TmpNetworkAdapter(aNetworkAdapter);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_ENTER(this, (void *)TmpNetworkAdapter.ptr(), aChangeAdapter != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onNetworkAdapterChange(TmpNetworkAdapter.ptr(),
                                         aChangeAdapter != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetworkAdapter.ptr(), aChangeAdapter != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aChangeAdapter != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aChangeAdapter != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onNetworkAdapterChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnAudioAdapterChange(IAudioAdapter *aAudioAdapter)
{
    LogRelFlow(("{%p} %s: enter aAudioAdapter=%p\n", this, "Session::onAudioAdapterChange", aAudioAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IAudioAdapter> TmpAudioAdapter(aAudioAdapter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_ENTER(this, (void *)TmpAudioAdapter.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onAudioAdapterChange(TmpAudioAdapter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpAudioAdapter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onAudioAdapterChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnHostAudioDeviceChange(IHostAudioDevice *aDevice,
                                                  BOOL aIsNew,
                                                  AudioDeviceState_T aState,
                                                  IVirtualBoxErrorInfo *aErrorInfo)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p aIsNew=%RTbool aState=%RU32 aErrorInfo=%p\n", this, "Session::onHostAudioDeviceChange", aDevice, aIsNew, aState, aErrorInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IHostAudioDevice> TmpDevice(aDevice);
        
        
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpErrorInfo(aErrorInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONHOSTAUDIODEVICECHANGE_ENTER(this, (void *)TmpDevice.ptr(), aIsNew != FALSE, aState, (void *)TmpErrorInfo.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onHostAudioDeviceChange(TmpDevice.ptr(),
                                          aIsNew != FALSE,
                                          aState,
                                          TmpErrorInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONHOSTAUDIODEVICECHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDevice.ptr(), aIsNew != FALSE, aState, (void *)TmpErrorInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONHOSTAUDIODEVICECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aIsNew != FALSE, aState, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONHOSTAUDIODEVICECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aIsNew != FALSE, aState, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onHostAudioDeviceChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnSerialPortChange(ISerialPort *aSerialPort)
{
    LogRelFlow(("{%p} %s: enter aSerialPort=%p\n", this, "Session::onSerialPortChange", aSerialPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<ISerialPort> TmpSerialPort(aSerialPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_ENTER(this, (void *)TmpSerialPort.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onSerialPortChange(TmpSerialPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSerialPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onSerialPortChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnParallelPortChange(IParallelPort *aParallelPort)
{
    LogRelFlow(("{%p} %s: enter aParallelPort=%p\n", this, "Session::onParallelPortChange", aParallelPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IParallelPort> TmpParallelPort(aParallelPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_ENTER(this, (void *)TmpParallelPort.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onParallelPortChange(TmpParallelPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpParallelPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onParallelPortChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnStorageControllerChange(IN_BSTR aMachineId,
                                                    IN_BSTR aControllerName)
{
    LogRelFlow(("{%p} %s: enter aMachineId=%ls aControllerName=%ls\n", this, "Session::onStorageControllerChange", aMachineId, aControllerName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpMachineId(aMachineId);
        BSTRInConverter TmpControllerName(aControllerName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_ENTER(this, TmpMachineId.uuid().toStringCurly().c_str(), TmpControllerName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onStorageControllerChange(TmpMachineId.uuid(),
                                            TmpControllerName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 0 /*normal*/, TmpMachineId.uuid().toStringCurly().c_str(), TmpControllerName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onStorageControllerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnMediumChange(IMediumAttachment *aMediumAttachment,
                                         BOOL aForce)
{
    LogRelFlow(("{%p} %s: enter aMediumAttachment=%p aForce=%RTbool\n", this, "Session::onMediumChange", aMediumAttachment, aForce));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_ENTER(this, (void *)TmpMediumAttachment.ptr(), aForce != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onMediumChange(TmpMediumAttachment.ptr(),
                                 aForce != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aForce != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aForce != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aForce != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onMediumChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnStorageDeviceChange(IMediumAttachment *aMediumAttachment,
                                                BOOL aRemove,
                                                BOOL aSilent)
{
    LogRelFlow(("{%p} %s: enter aMediumAttachment=%p aRemove=%RTbool aSilent=%RTbool\n", this, "Session::onStorageDeviceChange", aMediumAttachment, aRemove, aSilent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_ENTER(this, (void *)TmpMediumAttachment.ptr(), aRemove != FALSE, aSilent != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onStorageDeviceChange(TmpMediumAttachment.ptr(),
                                        aRemove != FALSE,
                                        aSilent != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aRemove != FALSE, aSilent != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aRemove != FALSE, aSilent != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aRemove != FALSE, aSilent != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onStorageDeviceChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnVMProcessPriorityChange(VMProcPriority_T aPriority)
{
    LogRelFlow(("{%p} %s: enter aPriority=%RU32\n", this, "Session::onVMProcessPriorityChange", aPriority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_ENTER(this, aPriority);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onVMProcessPriorityChange(aPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 0 /*normal*/, aPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onVMProcessPriorityChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnClipboardModeChange(ClipboardMode_T aClipboardMode)
{
    LogRelFlow(("{%p} %s: enter aClipboardMode=%RU32\n", this, "Session::onClipboardModeChange", aClipboardMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_ENTER(this, aClipboardMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onClipboardModeChange(aClipboardMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aClipboardMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aClipboardMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aClipboardMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onClipboardModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnClipboardFileTransferModeChange(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "Session::onClipboardFileTransferModeChange", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onClipboardFileTransferModeChange(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onClipboardFileTransferModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnDnDModeChange(DnDMode_T aDndMode)
{
    LogRelFlow(("{%p} %s: enter aDndMode=%RU32\n", this, "Session::onDnDModeChange", aDndMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_ENTER(this, aDndMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onDnDModeChange(aDndMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aDndMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aDndMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aDndMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onDnDModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnCPUChange(ULONG aCpu,
                                      BOOL aAdd)
{
    LogRelFlow(("{%p} %s: enter aCpu=%RU32 aAdd=%RTbool\n", this, "Session::onCPUChange", aCpu, aAdd));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_ENTER(this, aCpu, aAdd != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onCPUChange(aCpu,
                              aAdd != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 0 /*normal*/, aCpu, aAdd != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aCpu, aAdd != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aCpu, aAdd != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onCPUChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnCPUExecutionCapChange(ULONG aExecutionCap)
{
    LogRelFlow(("{%p} %s: enter aExecutionCap=%RU32\n", this, "Session::onCPUExecutionCapChange", aExecutionCap));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_ENTER(this, aExecutionCap);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onCPUExecutionCapChange(aExecutionCap);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 0 /*normal*/, aExecutionCap);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aExecutionCap);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aExecutionCap);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onCPUExecutionCapChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnVRDEServerChange(BOOL aRestart)
{
    LogRelFlow(("{%p} %s: enter aRestart=%RTbool\n", this, "Session::onVRDEServerChange", aRestart));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_ENTER(this, aRestart != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onVRDEServerChange(aRestart != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 0 /*normal*/, aRestart != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aRestart != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aRestart != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onVRDEServerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnRecordingStateChange(RecordingState_T aState,
                                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aState=%RU32 aProgress=%p\n", this, "Session::onRecordingStateChange", aState, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSTATECHANGE_ENTER(this, aState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onRecordingStateChange(aState,
                                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSTATECHANGE_RETURN(this, hrc, 0 /*normal*/, aState, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSTATECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aState, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSTATECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aState, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProgress=%p hrc=%Rhrc\n", this, "Session::onRecordingStateChange", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnRecordingScreenStateChange(RecordingState_T aState,
                                                       ULONG aScreen)
{
    LogRelFlow(("{%p} %s: enter aState=%RU32 aScreen=%RU32\n", this, "Session::onRecordingScreenStateChange", aState, aScreen));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSCREENSTATECHANGE_ENTER(this, aState, aScreen);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onRecordingScreenStateChange(aState,
                                               aScreen);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSCREENSTATECHANGE_RETURN(this, hrc, 0 /*normal*/, aState, aScreen);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSCREENSTATECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aState, aScreen);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGSCREENSTATECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aState, aScreen);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onRecordingScreenStateChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBControllerChange()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Session::onUSBControllerChange"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBControllerChange();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBControllerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnSharedFolderChange(BOOL aGlobal)
{
    LogRelFlow(("{%p} %s: enter aGlobal=%RTbool\n", this, "Session::onSharedFolderChange", aGlobal));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_ENTER(this, aGlobal != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onSharedFolderChange(aGlobal != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 0 /*normal*/, aGlobal != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aGlobal != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aGlobal != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onSharedFolderChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnGuestDebugControlChange(IGuestDebugControl *aGuestDebugControl)
{
    LogRelFlow(("{%p} %s: enter aGuestDebugControl=%p\n", this, "Session::onGuestDebugControlChange", aGuestDebugControl));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IGuestDebugControl> TmpGuestDebugControl(aGuestDebugControl);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONGUESTDEBUGCONTROLCHANGE_ENTER(this, (void *)TmpGuestDebugControl.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onGuestDebugControlChange(TmpGuestDebugControl.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONGUESTDEBUGCONTROLCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpGuestDebugControl.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONGUESTDEBUGCONTROLCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONGUESTDEBUGCONTROLCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onGuestDebugControlChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBDeviceAttach(IUSBDevice *aDevice,
                                            IVirtualBoxErrorInfo *aError,
                                            ULONG aMaskedInterfaces,
                                            IN_BSTR aCaptureFilename)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p aError=%p aMaskedInterfaces=%RU32 aCaptureFilename=%ls\n", this, "Session::onUSBDeviceAttach", aDevice, aError, aMaskedInterfaces, aCaptureFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IUSBDevice> TmpDevice(aDevice);
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpError(aError);
        
        BSTRInConverter TmpCaptureFilename(aCaptureFilename);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_ENTER(this, (void *)TmpDevice.ptr(), (void *)TmpError.ptr(), aMaskedInterfaces, TmpCaptureFilename.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBDeviceAttach(TmpDevice.ptr(),
                                    TmpError.ptr(),
                                    aMaskedInterfaces,
                                    TmpCaptureFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDevice.ptr(), (void *)TmpError.ptr(), aMaskedInterfaces, TmpCaptureFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aMaskedInterfaces, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aMaskedInterfaces, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBDeviceAttach", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBDeviceDetach(IN_BSTR aId,
                                            IVirtualBoxErrorInfo *aError)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aError=%p\n", this, "Session::onUSBDeviceDetach", aId, aError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpId(aId);
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpError(aError);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_ENTER(this, TmpId.uuid().toStringCurly().c_str(), (void *)TmpError.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBDeviceDetach(TmpId.uuid(),
                                    TmpError.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpError.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBDeviceDetach", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnShowWindow(BOOL aCheck,
                                       BOOL *aCanShow,
                                       LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s: enter aCheck=%RTbool aCanShow=%p aWinId=%p\n", this, "Session::onShowWindow", aCheck, aCanShow, aWinId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCanShow);
        CheckComArgOutPointerValidThrow(aWinId);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_ENTER(this, aCheck != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onShowWindow(aCheck != FALSE,
                               aCanShow,
                               aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 0 /*normal*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 1 /*hrc exception*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 9 /*unhandled exception*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCanShow=%RTbool *aWinId=%RI64 hrc=%Rhrc\n", this, "Session::onShowWindow", !RT_VALID_PTR(aCanShow) ? 0 : *aCanShow, !RT_VALID_PTR(aWinId) ? 0 : *aWinId, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroup=%p\n", this, "Session::onBandwidthGroupChange", aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_ENTER(this, (void *)TmpBandwidthGroup.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onBandwidthGroupChange(TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onBandwidthGroupChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::AccessGuestProperty(IN_BSTR aName,
                                              IN_BSTR aValue,
                                              IN_BSTR aFlags,
                                              ULONG aAccessMode,
                                              BSTR *aRetValue,
                                              LONG64 *aRetTimestamp,
                                              BSTR *aRetFlags)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%ls aFlags=%ls aAccessMode=%RU32 aRetValue=%p aRetTimestamp=%p aRetFlags=%p\n", this, "Session::accessGuestProperty", aName, aValue, aFlags, aAccessMode, aRetValue, aRetTimestamp, aRetFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRetValue);
        CheckComArgOutPointerValidThrow(aRetTimestamp);
        CheckComArgOutPointerValidThrow(aRetFlags);


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);
        BSTRInConverter TmpFlags(aFlags);
        
        BSTROutConverter TmpRetValue(aRetValue);
        
        BSTROutConverter TmpRetFlags(aRetFlags);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str(), aAccessMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = accessGuestProperty(TmpName.str(),
                                      TmpValue.str(),
                                      TmpFlags.str(),
                                      aAccessMode,
                                      TmpRetValue.str(),
                                      aRetTimestamp,
                                      TmpRetFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str(), aAccessMode, TmpRetValue.str().c_str(), *aRetTimestamp, TmpRetFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aAccessMode, 0, *aRetTimestamp, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aAccessMode, 0, *aRetTimestamp, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRetValue=%ls *aRetTimestamp=%RI64 *aRetFlags=%ls hrc=%Rhrc\n", this, "Session::accessGuestProperty", !RT_VALID_PTR(aRetValue) ? 0 : *aRetValue, !RT_VALID_PTR(aRetTimestamp) ? 0 : *aRetTimestamp, !RT_VALID_PTR(aRetFlags) ? 0 : *aRetFlags, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::EnumerateGuestProperties(IN_BSTR aPatterns,
                                                   ComSafeArrayOut(BSTR, aKeys),
                                                   ComSafeArrayOut(BSTR, aValues),
                                                   ComSafeArrayOut(LONG64, aTimestamps),
                                                   ComSafeArrayOut(BSTR, aFlags))
{
    LogRelFlow(("{%p} %s: enter aPatterns=%ls aKeys=%p aValues=%p aTimestamps=%p aFlags=%p\n", this, "Session::enumerateGuestProperties", aPatterns, aKeys, aValues, aTimestamps, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeys);
        CheckComArgOutPointerValidThrow(aValues);
        CheckComArgOutPointerValidThrow(aTimestamps);
        CheckComArgOutPointerValidThrow(aFlags);


        BSTRInConverter TmpPatterns(aPatterns);
        ArrayBSTROutConverter TmpKeys(ComSafeArrayOutArg(aKeys));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));
        ArrayOutConverter<LONG64> TmpTimestamps(ComSafeArrayOutArg(aTimestamps));
        ArrayBSTROutConverter TmpFlags(ComSafeArrayOutArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_ENTER(this, TmpPatterns.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enumerateGuestProperties(TmpPatterns.str(),
                                           TmpKeys.array(),
                                           TmpValues.array(),
                                           TmpTimestamps.array(),
                                           TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 0 /*normal*/, TmpPatterns.str().c_str(), (uint32_t)TmpKeys.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/, (uint32_t)TmpTimestamps.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeys=%zu *aValues=%zu *aTimestamps=%zu *aFlags=%zu hrc=%Rhrc\n", this, "Session::enumerateGuestProperties", !RT_VALID_PTR(aKeys) ? 0 : ComSafeArraySize(*aKeys), !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), !RT_VALID_PTR(aTimestamps) ? 0 : ComSafeArraySize(*aTimestamps), !RT_VALID_PTR(aFlags) ? 0 : ComSafeArraySize(*aFlags), hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnlineMergeMedium(IMediumAttachment *aMediumAttachment,
                                            ULONG aSourceIdx,
                                            ULONG aTargetIdx,
                                            IProgress *aProgress)
{
    LogRelFlow(("{%p} %s: enter aMediumAttachment=%p aSourceIdx=%RU32 aTargetIdx=%RU32 aProgress=%p\n", this, "Session::onlineMergeMedium", aMediumAttachment, aSourceIdx, aTargetIdx, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        
        
        ComTypeInConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_ENTER(this, (void *)TmpMediumAttachment.ptr(), aSourceIdx, aTargetIdx, (void *)TmpProgress.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = onlineMergeMedium(TmpMediumAttachment.ptr(),
                                    aSourceIdx,
                                    aTargetIdx,
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aSourceIdx, aTargetIdx, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aSourceIdx, aTargetIdx, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aSourceIdx, aTargetIdx, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onlineMergeMedium", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::ReconfigureMediumAttachments(ComSafeArrayIn(IMediumAttachment *, aAttachments))
{
    LogRelFlow(("{%p} %s: enter aAttachments=%zu\n", this, "Session::reconfigureMediumAttachments", aAttachments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayComTypeInConverter<IMediumAttachment> TmpAttachments(ComSafeArrayInArg(aAttachments));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_ENTER(this, (uint32_t)TmpAttachments.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reconfigureMediumAttachments(TmpAttachments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpAttachments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::reconfigureMediumAttachments", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::EnableVMMStatistics(BOOL aEnable)
{
    LogRelFlow(("{%p} %s: enter aEnable=%RTbool\n", this, "Session::enableVMMStatistics", aEnable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_ENTER(this, aEnable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enableVMMStatistics(aEnable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 0 /*normal*/, aEnable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 1 /*hrc exception*/, aEnable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 9 /*unhandled exception*/, aEnable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::enableVMMStatistics", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::PauseWithReason(Reason_T aReason)
{
    LogRelFlow(("{%p} %s: enter aReason=%RU32\n", this, "Session::pauseWithReason", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_ENTER(this, aReason);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = pauseWithReason(aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::pauseWithReason", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::ResumeWithReason(Reason_T aReason)
{
    LogRelFlow(("{%p} %s: enter aReason=%RU32\n", this, "Session::resumeWithReason", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_ENTER(this, aReason);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resumeWithReason(aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::resumeWithReason", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::SaveStateWithReason(Reason_T aReason,
                                              IProgress *aProgress,
                                              ISnapshot *aSnapshot,
                                              IN_BSTR aStateFilePath,
                                              BOOL aPauseVM,
                                              BOOL *aLeftPaused)
{
    LogRelFlow(("{%p} %s: enter aReason=%RU32 aProgress=%p aSnapshot=%p aStateFilePath=%ls aPauseVM=%RTbool aLeftPaused=%p\n", this, "Session::saveStateWithReason", aReason, aProgress, aSnapshot, aStateFilePath, aPauseVM, aLeftPaused));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLeftPaused);


        
        ComTypeInConverter<IProgress> TmpProgress(aProgress);
        ComTypeInConverter<ISnapshot> TmpSnapshot(aSnapshot);
        BSTRInConverter TmpStateFilePath(aStateFilePath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_ENTER(this, aReason, (void *)TmpProgress.ptr(), (void *)TmpSnapshot.ptr(), TmpStateFilePath.str().c_str(), aPauseVM != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = saveStateWithReason(aReason,
                                      TmpProgress.ptr(),
                                      TmpSnapshot.ptr(),
                                      TmpStateFilePath.str(),
                                      aPauseVM != FALSE,
                                      aLeftPaused);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason, (void *)TmpProgress.ptr(), (void *)TmpSnapshot.ptr(), TmpStateFilePath.str().c_str(), aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason, 0, 0, 0, aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason, 0, 0, 0, aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLeftPaused=%RTbool hrc=%Rhrc\n", this, "Session::saveStateWithReason", !RT_VALID_PTR(aLeftPaused) ? 0 : *aLeftPaused, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::CancelSaveStateWithReason()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Session::cancelSaveStateWithReason"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancelSaveStateWithReason();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::cancelSaveStateWithReason", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SessionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionWrap, ISession, IInternalSessionControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SessionWrap.cpp"


// ##### BEGINFILE "StorageControllerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IStorageController.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_STORAGECONTROLLER

#include "StorageControllerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(StorageControllerWrap)

//
// IStorageController properties
//

STDMETHODIMP StorageControllerWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "StorageController::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "StorageController::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "StorageController::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setName", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MaxDevicesPerPortCount)(ULONG *aMaxDevicesPerPortCount)
{
    LogRelFlow(("{%p} %s: enter aMaxDevicesPerPortCount=%p\n", this, "StorageController::getMaxDevicesPerPortCount", aMaxDevicesPerPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxDevicesPerPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxDevicesPerPortCount(aMaxDevicesPerPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMaxDevicesPerPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxDevicesPerPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxDevicesPerPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxDevicesPerPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMaxDevicesPerPortCount", !RT_VALID_PTR(aMaxDevicesPerPortCount) ? 0 : *aMaxDevicesPerPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MinPortCount)(ULONG *aMinPortCount)
{
    LogRelFlow(("{%p} %s: enter aMinPortCount=%p\n", this, "StorageController::getMinPortCount", aMinPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinPortCount(aMinPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMinPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMinPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMinPortCount", !RT_VALID_PTR(aMinPortCount) ? 0 : *aMinPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MaxPortCount)(ULONG *aMaxPortCount)
{
    LogRelFlow(("{%p} %s: enter aMaxPortCount=%p\n", this, "StorageController::getMaxPortCount", aMaxPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxPortCount(aMaxPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMaxPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMaxPortCount", !RT_VALID_PTR(aMaxPortCount) ? 0 : *aMaxPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Instance)(ULONG *aInstance)
{
    LogRelFlow(("{%p} %s: enter aInstance=%p\n", this, "StorageController::getInstance", aInstance));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInstance);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstance(aInstance);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 0 /*normal*/,*aInstance);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 1 /*hrc exception*/,*aInstance);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInstance);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInstance=%RU32 hrc=%Rhrc\n", this, "StorageController::getInstance", !RT_VALID_PTR(aInstance) ? 0 : *aInstance, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(Instance)(ULONG aInstance)
{
    LogRelFlow(("{%p} %s: enter aInstance=%RU32\n", this, "StorageController::setInstance", aInstance));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_ENTER(this, aInstance);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInstance(aInstance);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 0 /*normal*/,aInstance);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 1 /*hrc exception*/,aInstance);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/,aInstance);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setInstance", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(PortCount)(ULONG *aPortCount)
{
    LogRelFlow(("{%p} %s: enter aPortCount=%p\n", this, "StorageController::getPortCount", aPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPortCount(aPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getPortCount", !RT_VALID_PTR(aPortCount) ? 0 : *aPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(PortCount)(ULONG aPortCount)
{
    LogRelFlow(("{%p} %s: enter aPortCount=%RU32\n", this, "StorageController::setPortCount", aPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_ENTER(this, aPortCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPortCount(aPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 0 /*normal*/,aPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setPortCount", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Bus)(StorageBus_T *aBus)
{
    LogRelFlow(("{%p} %s: enter aBus=%p\n", this, "StorageController::getBus", aBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBus(aBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 0 /*normal*/,*aBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 1 /*hrc exception*/,*aBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBus=%RU32 hrc=%Rhrc\n", this, "StorageController::getBus", !RT_VALID_PTR(aBus) ? 0 : *aBus, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(ControllerType)(StorageControllerType_T *aControllerType)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%p\n", this, "StorageController::getControllerType", aControllerType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aControllerType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getControllerType(aControllerType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/,*aControllerType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aControllerType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aControllerType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aControllerType=%RU32 hrc=%Rhrc\n", this, "StorageController::getControllerType", !RT_VALID_PTR(aControllerType) ? 0 : *aControllerType, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(ControllerType)(StorageControllerType_T aControllerType)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%RU32\n", this, "StorageController::setControllerType", aControllerType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_ENTER(this, aControllerType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setControllerType(aControllerType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/,aControllerType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aControllerType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aControllerType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setControllerType", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(UseHostIOCache)(BOOL *aUseHostIOCache)
{
    LogRelFlow(("{%p} %s: enter aUseHostIOCache=%p\n", this, "StorageController::getUseHostIOCache", aUseHostIOCache));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUseHostIOCache);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUseHostIOCache(aUseHostIOCache);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 0 /*normal*/,*aUseHostIOCache != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 1 /*hrc exception*/,*aUseHostIOCache != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUseHostIOCache != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUseHostIOCache=%RTbool hrc=%Rhrc\n", this, "StorageController::getUseHostIOCache", !RT_VALID_PTR(aUseHostIOCache) ? 0 : *aUseHostIOCache, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(UseHostIOCache)(BOOL aUseHostIOCache)
{
    LogRelFlow(("{%p} %s: enter aUseHostIOCache=%RTbool\n", this, "StorageController::setUseHostIOCache", aUseHostIOCache));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_ENTER(this, aUseHostIOCache != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUseHostIOCache(aUseHostIOCache != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 0 /*normal*/,aUseHostIOCache != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 1 /*hrc exception*/,aUseHostIOCache != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 9 /*unhandled exception*/,aUseHostIOCache != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setUseHostIOCache", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Bootable)(BOOL *aBootable)
{
    LogRelFlow(("{%p} %s: enter aBootable=%p\n", this, "StorageController::getBootable", aBootable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBootable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootable(aBootable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 0 /*normal*/,*aBootable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aBootable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBootable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBootable=%RTbool hrc=%Rhrc\n", this, "StorageController::getBootable", !RT_VALID_PTR(aBootable) ? 0 : *aBootable, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute1IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute2IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute3IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute4IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute5IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute6IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute7IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute8IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IStorageController methods
//

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod1IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod2IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod3IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod4IStorageController()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(StorageControllerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(StorageControllerWrap, IStorageController)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "StorageControllerWrap.cpp"


// ##### BEGINFILE "PerformanceMetricWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPerformanceMetric.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PERFORMANCEMETRIC

#include "PerformanceMetricWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PerformanceMetricWrap)

//
// IPerformanceMetric properties
//

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MetricName)(BSTR *aMetricName)
{
    LogRelFlow(("{%p} %s: enter aMetricName=%p\n", this, "PerformanceMetric::getMetricName", aMetricName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMetricName);
        BSTROutConverter TmpMetricName(aMetricName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMetricName(TmpMetricName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 0 /*normal*/,TmpMetricName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMetricName=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getMetricName", !RT_VALID_PTR(aMetricName) ? 0 : *aMetricName, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Object)(IUnknown **aObject)
{
    LogRelFlow(("{%p} %s: enter aObject=%p\n", this, "PerformanceMetric::getObject", aObject));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObject);
        ComTypeOutConverter<IUnknown> TmpObject(aObject);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getObject(TmpObject.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpObject.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aObject=%p hrc=%Rhrc\n", this, "PerformanceMetric::getObject", !RT_VALID_PTR(aObject) ? 0 : *aObject, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "PerformanceMetric::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Period)(ULONG *aPeriod)
{
    LogRelFlow(("{%p} %s: enter aPeriod=%p\n", this, "PerformanceMetric::getPeriod", aPeriod));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPeriod);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPeriod(aPeriod);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 0 /*normal*/,*aPeriod);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 1 /*hrc exception*/,*aPeriod);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 9 /*unhandled exception*/,*aPeriod);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPeriod=%RU32 hrc=%Rhrc\n", this, "PerformanceMetric::getPeriod", !RT_VALID_PTR(aPeriod) ? 0 : *aPeriod, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Count)(ULONG *aCount)
{
    LogRelFlow(("{%p} %s: enter aCount=%p\n", this, "PerformanceMetric::getCount", aCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCount(aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 0 /*normal*/,*aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCount=%RU32 hrc=%Rhrc\n", this, "PerformanceMetric::getCount", !RT_VALID_PTR(aCount) ? 0 : *aCount, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Unit)(BSTR *aUnit)
{
    LogRelFlow(("{%p} %s: enter aUnit=%p\n", this, "PerformanceMetric::getUnit", aUnit));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUnit);
        BSTROutConverter TmpUnit(aUnit);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUnit(TmpUnit.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 0 /*normal*/,TmpUnit.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUnit=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getUnit", !RT_VALID_PTR(aUnit) ? 0 : *aUnit, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MinimumValue)(LONG *aMinimumValue)
{
    LogRelFlow(("{%p} %s: enter aMinimumValue=%p\n", this, "PerformanceMetric::getMinimumValue", aMinimumValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinimumValue);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinimumValue(aMinimumValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 0 /*normal*/,*aMinimumValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 1 /*hrc exception*/,*aMinimumValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinimumValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinimumValue=%RI32 hrc=%Rhrc\n", this, "PerformanceMetric::getMinimumValue", !RT_VALID_PTR(aMinimumValue) ? 0 : *aMinimumValue, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MaximumValue)(LONG *aMaximumValue)
{
    LogRelFlow(("{%p} %s: enter aMaximumValue=%p\n", this, "PerformanceMetric::getMaximumValue", aMaximumValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaximumValue);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaximumValue(aMaximumValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 0 /*normal*/,*aMaximumValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 1 /*hrc exception*/,*aMaximumValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaximumValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaximumValue=%RI32 hrc=%Rhrc\n", this, "PerformanceMetric::getMaximumValue", !RT_VALID_PTR(aMaximumValue) ? 0 : *aMaximumValue, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute1IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute2IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute3IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute4IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute5IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute6IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute7IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute8IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPerformanceMetric methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PerformanceMetricWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceMetricWrap, IPerformanceMetric)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PerformanceMetricWrap.cpp"


// ##### BEGINFILE "NATEngineWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for INATEngine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_NATENGINE

#include "NATEngineWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(NATEngineWrap)

//
// INATEngine properties
//

STDMETHODIMP NATEngineWrap::COMGETTER(Network)(BSTR *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "NATEngine::getNetwork", aNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);
        BSTROutConverter TmpNetwork(aNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetwork(TmpNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetwork=%ls hrc=%Rhrc\n", this, "NATEngine::getNetwork", !RT_VALID_PTR(aNetwork) ? 0 : *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(Network)(IN_BSTR aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%ls\n", this, "NATEngine::setNetwork", aNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_ENTER(this, TmpNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetwork(TmpNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setNetwork", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(HostIP)(BSTR *aHostIP)
{
    LogRelFlow(("{%p} %s: enter aHostIP=%p\n", this, "NATEngine::getHostIP", aHostIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostIP);
        BSTROutConverter TmpHostIP(aHostIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostIP(TmpHostIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 0 /*normal*/,TmpHostIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostIP=%ls hrc=%Rhrc\n", this, "NATEngine::getHostIP", !RT_VALID_PTR(aHostIP) ? 0 : *aHostIP, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(HostIP)(IN_BSTR aHostIP)
{
    LogRelFlow(("{%p} %s: enter aHostIP=%ls\n", this, "NATEngine::setHostIP", aHostIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpHostIP(aHostIP);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_ENTER(this, TmpHostIP.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostIP(TmpHostIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 0 /*normal*/,TmpHostIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setHostIP", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPPrefix)(BSTR *aTFTPPrefix)
{
    LogRelFlow(("{%p} %s: enter aTFTPPrefix=%p\n", this, "NATEngine::getTFTPPrefix", aTFTPPrefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPPrefix);
        BSTROutConverter TmpTFTPPrefix(aTFTPPrefix);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPPrefix(TmpTFTPPrefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 0 /*normal*/,TmpTFTPPrefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPPrefix=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPPrefix", !RT_VALID_PTR(aTFTPPrefix) ? 0 : *aTFTPPrefix, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPPrefix)(IN_BSTR aTFTPPrefix)
{
    LogRelFlow(("{%p} %s: enter aTFTPPrefix=%ls\n", this, "NATEngine::setTFTPPrefix", aTFTPPrefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPPrefix(aTFTPPrefix);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_ENTER(this, TmpTFTPPrefix.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPPrefix(TmpTFTPPrefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 0 /*normal*/,TmpTFTPPrefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPPrefix", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPBootFile)(BSTR *aTFTPBootFile)
{
    LogRelFlow(("{%p} %s: enter aTFTPBootFile=%p\n", this, "NATEngine::getTFTPBootFile", aTFTPBootFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPBootFile);
        BSTROutConverter TmpTFTPBootFile(aTFTPBootFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPBootFile(TmpTFTPBootFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 0 /*normal*/,TmpTFTPBootFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPBootFile=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPBootFile", !RT_VALID_PTR(aTFTPBootFile) ? 0 : *aTFTPBootFile, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPBootFile)(IN_BSTR aTFTPBootFile)
{
    LogRelFlow(("{%p} %s: enter aTFTPBootFile=%ls\n", this, "NATEngine::setTFTPBootFile", aTFTPBootFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPBootFile(aTFTPBootFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_ENTER(this, TmpTFTPBootFile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPBootFile(TmpTFTPBootFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 0 /*normal*/,TmpTFTPBootFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPBootFile", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPNextServer)(BSTR *aTFTPNextServer)
{
    LogRelFlow(("{%p} %s: enter aTFTPNextServer=%p\n", this, "NATEngine::getTFTPNextServer", aTFTPNextServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPNextServer);
        BSTROutConverter TmpTFTPNextServer(aTFTPNextServer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPNextServer(TmpTFTPNextServer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 0 /*normal*/,TmpTFTPNextServer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPNextServer=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPNextServer", !RT_VALID_PTR(aTFTPNextServer) ? 0 : *aTFTPNextServer, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPNextServer)(IN_BSTR aTFTPNextServer)
{
    LogRelFlow(("{%p} %s: enter aTFTPNextServer=%ls\n", this, "NATEngine::setTFTPNextServer", aTFTPNextServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPNextServer(aTFTPNextServer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_ENTER(this, TmpTFTPNextServer.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPNextServer(TmpTFTPNextServer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 0 /*normal*/,TmpTFTPNextServer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPNextServer", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(AliasMode)(ULONG *aAliasMode)
{
    LogRelFlow(("{%p} %s: enter aAliasMode=%p\n", this, "NATEngine::getAliasMode", aAliasMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAliasMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAliasMode(aAliasMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 0 /*normal*/,*aAliasMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAliasMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAliasMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAliasMode=%RU32 hrc=%Rhrc\n", this, "NATEngine::getAliasMode", !RT_VALID_PTR(aAliasMode) ? 0 : *aAliasMode, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(AliasMode)(ULONG aAliasMode)
{
    LogRelFlow(("{%p} %s: enter aAliasMode=%RU32\n", this, "NATEngine::setAliasMode", aAliasMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_ENTER(this, aAliasMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAliasMode(aAliasMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 0 /*normal*/,aAliasMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 1 /*hrc exception*/,aAliasMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aAliasMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setAliasMode", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSPassDomain)(BOOL *aDNSPassDomain)
{
    LogRelFlow(("{%p} %s: enter aDNSPassDomain=%p\n", this, "NATEngine::getDNSPassDomain", aDNSPassDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSPassDomain);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSPassDomain(aDNSPassDomain);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 0 /*normal*/,*aDNSPassDomain != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSPassDomain != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSPassDomain != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSPassDomain=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSPassDomain", !RT_VALID_PTR(aDNSPassDomain) ? 0 : *aDNSPassDomain, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSPassDomain)(BOOL aDNSPassDomain)
{
    LogRelFlow(("{%p} %s: enter aDNSPassDomain=%RTbool\n", this, "NATEngine::setDNSPassDomain", aDNSPassDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_ENTER(this, aDNSPassDomain != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSPassDomain(aDNSPassDomain != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 0 /*normal*/,aDNSPassDomain != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,aDNSPassDomain != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSPassDomain != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSPassDomain", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSProxy)(BOOL *aDNSProxy)
{
    LogRelFlow(("{%p} %s: enter aDNSProxy=%p\n", this, "NATEngine::getDNSProxy", aDNSProxy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSProxy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSProxy(aDNSProxy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 0 /*normal*/,*aDNSProxy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSProxy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSProxy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSProxy=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSProxy", !RT_VALID_PTR(aDNSProxy) ? 0 : *aDNSProxy, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSProxy)(BOOL aDNSProxy)
{
    LogRelFlow(("{%p} %s: enter aDNSProxy=%RTbool\n", this, "NATEngine::setDNSProxy", aDNSProxy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_ENTER(this, aDNSProxy != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSProxy(aDNSProxy != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 0 /*normal*/,aDNSProxy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 1 /*hrc exception*/,aDNSProxy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSProxy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSProxy", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSUseHostResolver)(BOOL *aDNSUseHostResolver)
{
    LogRelFlow(("{%p} %s: enter aDNSUseHostResolver=%p\n", this, "NATEngine::getDNSUseHostResolver", aDNSUseHostResolver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSUseHostResolver);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSUseHostResolver(aDNSUseHostResolver);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 0 /*normal*/,*aDNSUseHostResolver != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSUseHostResolver != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSUseHostResolver != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSUseHostResolver=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSUseHostResolver", !RT_VALID_PTR(aDNSUseHostResolver) ? 0 : *aDNSUseHostResolver, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSUseHostResolver)(BOOL aDNSUseHostResolver)
{
    LogRelFlow(("{%p} %s: enter aDNSUseHostResolver=%RTbool\n", this, "NATEngine::setDNSUseHostResolver", aDNSUseHostResolver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_ENTER(this, aDNSUseHostResolver != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSUseHostResolver(aDNSUseHostResolver != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 0 /*normal*/,aDNSUseHostResolver != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 1 /*hrc exception*/,aDNSUseHostResolver != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSUseHostResolver != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSUseHostResolver", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(Redirects)(ComSafeArrayOut(BSTR, aRedirects))
{
    LogRelFlow(("{%p} %s: enter aRedirects=%p\n", this, "NATEngine::getRedirects", aRedirects));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRedirects);
        ArrayBSTROutConverter TmpRedirects(ComSafeArrayOutArg(aRedirects));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRedirects(TmpRedirects.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpRedirects.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRedirects=%zu hrc=%Rhrc\n", this, "NATEngine::getRedirects", !RT_VALID_PTR(aRedirects) ? 0 : ComSafeArraySize(*aRedirects), hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(LocalhostReachable)(BOOL *aLocalhostReachable)
{
    LogRelFlow(("{%p} %s: enter aLocalhostReachable=%p\n", this, "NATEngine::getLocalhostReachable", aLocalhostReachable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLocalhostReachable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_LOCALHOSTREACHABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLocalhostReachable(aLocalhostReachable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_LOCALHOSTREACHABLE_RETURN(this, hrc, 0 /*normal*/,*aLocalhostReachable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_LOCALHOSTREACHABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aLocalhostReachable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_LOCALHOSTREACHABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aLocalhostReachable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLocalhostReachable=%RTbool hrc=%Rhrc\n", this, "NATEngine::getLocalhostReachable", !RT_VALID_PTR(aLocalhostReachable) ? 0 : *aLocalhostReachable, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(LocalhostReachable)(BOOL aLocalhostReachable)
{
    LogRelFlow(("{%p} %s: enter aLocalhostReachable=%RTbool\n", this, "NATEngine::setLocalhostReachable", aLocalhostReachable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_LOCALHOSTREACHABLE_ENTER(this, aLocalhostReachable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLocalhostReachable(aLocalhostReachable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_LOCALHOSTREACHABLE_RETURN(this, hrc, 0 /*normal*/,aLocalhostReachable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_LOCALHOSTREACHABLE_RETURN(this, hrc, 1 /*hrc exception*/,aLocalhostReachable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_LOCALHOSTREACHABLE_RETURN(this, hrc, 9 /*unhandled exception*/,aLocalhostReachable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setLocalhostReachable", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(ForwardBroadcast)(BOOL *aForwardBroadcast)
{
    LogRelFlow(("{%p} %s: enter aForwardBroadcast=%p\n", this, "NATEngine::getForwardBroadcast", aForwardBroadcast));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aForwardBroadcast);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_FORWARDBROADCAST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getForwardBroadcast(aForwardBroadcast);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_FORWARDBROADCAST_RETURN(this, hrc, 0 /*normal*/,*aForwardBroadcast != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_FORWARDBROADCAST_RETURN(this, hrc, 1 /*hrc exception*/,*aForwardBroadcast != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_FORWARDBROADCAST_RETURN(this, hrc, 9 /*unhandled exception*/,*aForwardBroadcast != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForwardBroadcast=%RTbool hrc=%Rhrc\n", this, "NATEngine::getForwardBroadcast", !RT_VALID_PTR(aForwardBroadcast) ? 0 : *aForwardBroadcast, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(ForwardBroadcast)(BOOL aForwardBroadcast)
{
    LogRelFlow(("{%p} %s: enter aForwardBroadcast=%RTbool\n", this, "NATEngine::setForwardBroadcast", aForwardBroadcast));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_FORWARDBROADCAST_ENTER(this, aForwardBroadcast != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setForwardBroadcast(aForwardBroadcast != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_FORWARDBROADCAST_RETURN(this, hrc, 0 /*normal*/,aForwardBroadcast != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_FORWARDBROADCAST_RETURN(this, hrc, 1 /*hrc exception*/,aForwardBroadcast != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_FORWARDBROADCAST_RETURN(this, hrc, 9 /*unhandled exception*/,aForwardBroadcast != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setForwardBroadcast", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(EnableTFTP)(BOOL *aEnableTFTP)
{
    LogRelFlow(("{%p} %s: enter aEnableTFTP=%p\n", this, "NATEngine::getEnableTFTP", aEnableTFTP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnableTFTP);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ENABLETFTP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnableTFTP(aEnableTFTP);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ENABLETFTP_RETURN(this, hrc, 0 /*normal*/,*aEnableTFTP != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ENABLETFTP_RETURN(this, hrc, 1 /*hrc exception*/,*aEnableTFTP != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ENABLETFTP_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnableTFTP != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnableTFTP=%RTbool hrc=%Rhrc\n", this, "NATEngine::getEnableTFTP", !RT_VALID_PTR(aEnableTFTP) ? 0 : *aEnableTFTP, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(EnableTFTP)(BOOL aEnableTFTP)
{
    LogRelFlow(("{%p} %s: enter aEnableTFTP=%RTbool\n", this, "NATEngine::setEnableTFTP", aEnableTFTP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ENABLETFTP_ENTER(this, aEnableTFTP != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnableTFTP(aEnableTFTP != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ENABLETFTP_RETURN(this, hrc, 0 /*normal*/,aEnableTFTP != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ENABLETFTP_RETURN(this, hrc, 1 /*hrc exception*/,aEnableTFTP != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ENABLETFTP_RETURN(this, hrc, 9 /*unhandled exception*/,aEnableTFTP != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setEnableTFTP", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(NatMRU)(ULONG *aNatMRU)
{
    LogRelFlow(("{%p} %s: enter aNatMRU=%p\n", this, "NATEngine::getNatMRU", aNatMRU));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNatMRU);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NATMRU_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNatMRU(aNatMRU);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NATMRU_RETURN(this, hrc, 0 /*normal*/,*aNatMRU);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NATMRU_RETURN(this, hrc, 1 /*hrc exception*/,*aNatMRU);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NATMRU_RETURN(this, hrc, 9 /*unhandled exception*/,*aNatMRU);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNatMRU=%RU32 hrc=%Rhrc\n", this, "NATEngine::getNatMRU", !RT_VALID_PTR(aNatMRU) ? 0 : *aNatMRU, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(NatMRU)(ULONG aNatMRU)
{
    LogRelFlow(("{%p} %s: enter aNatMRU=%RU32\n", this, "NATEngine::setNatMRU", aNatMRU));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NATMRU_ENTER(this, aNatMRU);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNatMRU(aNatMRU);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NATMRU_RETURN(this, hrc, 0 /*normal*/,aNatMRU);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NATMRU_RETURN(this, hrc, 1 /*hrc exception*/,aNatMRU);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NATMRU_RETURN(this, hrc, 9 /*unhandled exception*/,aNatMRU);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setNatMRU", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(IPv6Enabled)(BOOL *aIPv6Enabled)
{
    LogRelFlow(("{%p} %s: enter aIPv6Enabled=%p\n", this, "NATEngine::getIPv6Enabled", aIPv6Enabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIPv6Enabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIPv6Enabled(aIPv6Enabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6ENABLED_RETURN(this, hrc, 0 /*normal*/,*aIPv6Enabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aIPv6Enabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIPv6Enabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIPv6Enabled=%RTbool hrc=%Rhrc\n", this, "NATEngine::getIPv6Enabled", !RT_VALID_PTR(aIPv6Enabled) ? 0 : *aIPv6Enabled, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(IPv6Enabled)(BOOL aIPv6Enabled)
{
    LogRelFlow(("{%p} %s: enter aIPv6Enabled=%RTbool\n", this, "NATEngine::setIPv6Enabled", aIPv6Enabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6ENABLED_ENTER(this, aIPv6Enabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIPv6Enabled(aIPv6Enabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6ENABLED_RETURN(this, hrc, 0 /*normal*/,aIPv6Enabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aIPv6Enabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aIPv6Enabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setIPv6Enabled", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(IPv6Prefix)(BSTR *aIPv6Prefix)
{
    LogRelFlow(("{%p} %s: enter aIPv6Prefix=%p\n", this, "NATEngine::getIPv6Prefix", aIPv6Prefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIPv6Prefix);
        BSTROutConverter TmpIPv6Prefix(aIPv6Prefix);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6PREFIX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIPv6Prefix(TmpIPv6Prefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6PREFIX_RETURN(this, hrc, 0 /*normal*/,TmpIPv6Prefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6PREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_IPV6PREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIPv6Prefix=%ls hrc=%Rhrc\n", this, "NATEngine::getIPv6Prefix", !RT_VALID_PTR(aIPv6Prefix) ? 0 : *aIPv6Prefix, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(IPv6Prefix)(IN_BSTR aIPv6Prefix)
{
    LogRelFlow(("{%p} %s: enter aIPv6Prefix=%ls\n", this, "NATEngine::setIPv6Prefix", aIPv6Prefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpIPv6Prefix(aIPv6Prefix);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6PREFIX_ENTER(this, TmpIPv6Prefix.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIPv6Prefix(TmpIPv6Prefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6PREFIX_RETURN(this, hrc, 0 /*normal*/,TmpIPv6Prefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6PREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_IPV6PREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setIPv6Prefix", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute1INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute2INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute3INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute4INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute5INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute6INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// INATEngine methods
//

STDMETHODIMP NATEngineWrap::SetNetworkSettings(ULONG aMtu,
                                               ULONG aSockSnd,
                                               ULONG aSockRcv,
                                               ULONG aTcpWndSnd,
                                               ULONG aTcpWndRcv)
{
    LogRelFlow(("{%p} %s: enter aMtu=%RU32 aSockSnd=%RU32 aSockRcv=%RU32 aTcpWndSnd=%RU32 aTcpWndRcv=%RU32\n", this, "NATEngine::setNetworkSettings", aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_ENTER(this, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetworkSettings(aMtu,
                                     aSockSnd,
                                     aSockRcv,
                                     aTcpWndSnd,
                                     aTcpWndRcv);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 0 /*normal*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setNetworkSettings", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::GetNetworkSettings(ULONG *aMtu,
                                               ULONG *aSockSnd,
                                               ULONG *aSockRcv,
                                               ULONG *aTcpWndSnd,
                                               ULONG *aTcpWndRcv)
{
    LogRelFlow(("{%p} %s: enter aMtu=%p aSockSnd=%p aSockRcv=%p aTcpWndSnd=%p aTcpWndRcv=%p\n", this, "NATEngine::getNetworkSettings", aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMtu);
        CheckComArgOutPointerValidThrow(aSockSnd);
        CheckComArgOutPointerValidThrow(aSockRcv);
        CheckComArgOutPointerValidThrow(aTcpWndSnd);
        CheckComArgOutPointerValidThrow(aTcpWndRcv);


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkSettings(aMtu,
                                     aSockSnd,
                                     aSockRcv,
                                     aTcpWndSnd,
                                     aTcpWndRcv);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 0 /*normal*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMtu=%RU32 *aSockSnd=%RU32 *aSockRcv=%RU32 *aTcpWndSnd=%RU32 *aTcpWndRcv=%RU32 hrc=%Rhrc\n", this, "NATEngine::getNetworkSettings", !RT_VALID_PTR(aMtu) ? 0 : *aMtu, !RT_VALID_PTR(aSockSnd) ? 0 : *aSockSnd, !RT_VALID_PTR(aSockRcv) ? 0 : *aSockRcv, !RT_VALID_PTR(aTcpWndSnd) ? 0 : *aTcpWndSnd, !RT_VALID_PTR(aTcpWndRcv) ? 0 : *aTcpWndRcv, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::AddRedirect(IN_BSTR aName,
                                        NATProtocol_T aProto,
                                        IN_BSTR aHostIP,
                                        USHORT aHostPort,
                                        IN_BSTR aGuestIP,
                                        USHORT aGuestPort)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aProto=%RU32 aHostIP=%ls aHostPort=%RU16 aGuestIP=%ls aGuestPort=%RU16\n", this, "NATEngine::addRedirect", aName, aProto, aHostIP, aHostPort, aGuestIP, aGuestPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        BSTRInConverter TmpHostIP(aHostIP);
        
        BSTRInConverter TmpGuestIP(aGuestIP);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_ENTER(this, TmpName.str().c_str(), aProto, TmpHostIP.str().c_str(), aHostPort, TmpGuestIP.str().c_str(), aGuestPort);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addRedirect(TmpName.str(),
                              aProto,
                              TmpHostIP.str(),
                              aHostPort,
                              TmpGuestIP.str(),
                              aGuestPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aProto, TmpHostIP.str().c_str(), aHostPort, TmpGuestIP.str().c_str(), aGuestPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::addRedirect", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::RemoveRedirect(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "NATEngine::removeRedirect", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeRedirect(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::removeRedirect", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod1INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod2INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod3INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod4INATEngine()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(NATEngineWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NATEngineWrap, INATEngine)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "NATEngineWrap.cpp"


// ##### BEGINFILE "ExtPackBaseWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackBase.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_EXTPACKBASE

#include "ExtPackBaseWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackBaseWrap)

//
// IExtPackBase properties
//

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPackBase::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPackBase::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPackBase::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPackBase::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "ExtPackBase::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "ExtPackBase::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPackBase::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPackBase::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Edition)(BSTR *aEdition)
{
    LogRelFlow(("{%p} %s: enter aEdition=%p\n", this, "ExtPackBase::getEdition", aEdition));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEdition);
        BSTROutConverter TmpEdition(aEdition);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEdition(TmpEdition.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 0 /*normal*/,TmpEdition.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEdition=%ls hrc=%Rhrc\n", this, "ExtPackBase::getEdition", !RT_VALID_PTR(aEdition) ? 0 : *aEdition, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(VRDEModule)(BSTR *aVRDEModule)
{
    LogRelFlow(("{%p} %s: enter aVRDEModule=%p\n", this, "ExtPackBase::getVRDEModule", aVRDEModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEModule);
        BSTROutConverter TmpVRDEModule(aVRDEModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEModule(TmpVRDEModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 0 /*normal*/,TmpVRDEModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEModule=%ls hrc=%Rhrc\n", this, "ExtPackBase::getVRDEModule", !RT_VALID_PTR(aVRDEModule) ? 0 : *aVRDEModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(CryptoModule)(BSTR *aCryptoModule)
{
    LogRelFlow(("{%p} %s: enter aCryptoModule=%p\n", this, "ExtPackBase::getCryptoModule", aCryptoModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCryptoModule);
        BSTROutConverter TmpCryptoModule(aCryptoModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_CRYPTOMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCryptoModule(TmpCryptoModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_CRYPTOMODULE_RETURN(this, hrc, 0 /*normal*/,TmpCryptoModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_CRYPTOMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_CRYPTOMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCryptoModule=%ls hrc=%Rhrc\n", this, "ExtPackBase::getCryptoModule", !RT_VALID_PTR(aCryptoModule) ? 0 : *aCryptoModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(PlugIns)(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns))
{
    LogRelFlow(("{%p} %s: enter aPlugIns=%p\n", this, "ExtPackBase::getPlugIns", aPlugIns));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugIns);
        ArrayComTypeOutConverter<IExtPackPlugIn> TmpPlugIns(ComSafeArrayOutArg(aPlugIns));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlugIns(TmpPlugIns.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPlugIns.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlugIns=%zu hrc=%Rhrc\n", this, "ExtPackBase::getPlugIns", !RT_VALID_PTR(aPlugIns) ? 0 : ComSafeArraySize(*aPlugIns), hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Usable)(BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aUsable=%p\n", this, "ExtPackBase::getUsable", aUsable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUsable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsable(aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 0 /*normal*/,*aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aUsable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPackBase::getUsable", !RT_VALID_PTR(aUsable) ? 0 : *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(WhyUnusable)(BSTR *aWhyUnusable)
{
    LogRelFlow(("{%p} %s: enter aWhyUnusable=%p\n", this, "ExtPackBase::getWhyUnusable", aWhyUnusable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWhyUnusable);
        BSTROutConverter TmpWhyUnusable(aWhyUnusable);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWhyUnusable(TmpWhyUnusable.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 0 /*normal*/,TmpWhyUnusable.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWhyUnusable=%ls hrc=%Rhrc\n", this, "ExtPackBase::getWhyUnusable", !RT_VALID_PTR(aWhyUnusable) ? 0 : *aWhyUnusable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(ShowLicense)(BOOL *aShowLicense)
{
    LogRelFlow(("{%p} %s: enter aShowLicense=%p\n", this, "ExtPackBase::getShowLicense", aShowLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShowLicense);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShowLicense(aShowLicense);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 0 /*normal*/,*aShowLicense != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 1 /*hrc exception*/,*aShowLicense != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,*aShowLicense != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShowLicense=%RTbool hrc=%Rhrc\n", this, "ExtPackBase::getShowLicense", !RT_VALID_PTR(aShowLicense) ? 0 : *aShowLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(License)(BSTR *aLicense)
{
    LogRelFlow(("{%p} %s: enter aLicense=%p\n", this, "ExtPackBase::getLicense", aLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicense);
        BSTROutConverter TmpLicense(aLicense);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLicense(TmpLicense.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 0 /*normal*/,TmpLicense.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLicense=%ls hrc=%Rhrc\n", this, "ExtPackBase::getLicense", !RT_VALID_PTR(aLicense) ? 0 : *aLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute1IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute2IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute3IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute4IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute5IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute6IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute7IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute8IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackBase methods
//

STDMETHODIMP ExtPackBaseWrap::QueryLicense(IN_BSTR aPreferredLocale,
                                           IN_BSTR aPreferredLanguage,
                                           IN_BSTR aFormat,
                                           BSTR *aLicenseText)
{
    LogRelFlow(("{%p} %s: enter aPreferredLocale=%ls aPreferredLanguage=%ls aFormat=%ls aLicenseText=%p\n", this, "ExtPackBase::queryLicense", aPreferredLocale, aPreferredLanguage, aFormat, aLicenseText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicenseText);


        BSTRInConverter TmpPreferredLocale(aPreferredLocale);
        BSTRInConverter TmpPreferredLanguage(aPreferredLanguage);
        BSTRInConverter TmpFormat(aFormat);
        BSTROutConverter TmpLicenseText(aLicenseText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_ENTER(this, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryLicense(TmpPreferredLocale.str(),
                               TmpPreferredLanguage.str(),
                               TmpFormat.str(),
                               TmpLicenseText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 0 /*normal*/, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str(), TmpLicenseText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLicenseText=%ls hrc=%Rhrc\n", this, "ExtPackBase::queryLicense", !RT_VALID_PTR(aLicenseText) ? 0 : *aLicenseText, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod1IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod2IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod3IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod4IExtPackBase()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackBaseWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackBaseWrap, IExtPackBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackBaseWrap.cpp"


// ##### BEGINFILE "ExtPackFileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_EXTPACKFILE

#include "ExtPackFileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackFileWrap)

//
// IExtPackBase properties
//

STDMETHODIMP ExtPackFileWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPackFile::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPackFile::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPackFile::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPackFile::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "ExtPackFile::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "ExtPackFile::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPackFile::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPackFile::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Edition)(BSTR *aEdition)
{
    LogRelFlow(("{%p} %s: enter aEdition=%p\n", this, "ExtPackFile::getEdition", aEdition));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEdition);
        BSTROutConverter TmpEdition(aEdition);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEdition(TmpEdition.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 0 /*normal*/,TmpEdition.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEdition=%ls hrc=%Rhrc\n", this, "ExtPackFile::getEdition", !RT_VALID_PTR(aEdition) ? 0 : *aEdition, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(VRDEModule)(BSTR *aVRDEModule)
{
    LogRelFlow(("{%p} %s: enter aVRDEModule=%p\n", this, "ExtPackFile::getVRDEModule", aVRDEModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEModule);
        BSTROutConverter TmpVRDEModule(aVRDEModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEModule(TmpVRDEModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 0 /*normal*/,TmpVRDEModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEModule=%ls hrc=%Rhrc\n", this, "ExtPackFile::getVRDEModule", !RT_VALID_PTR(aVRDEModule) ? 0 : *aVRDEModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(CryptoModule)(BSTR *aCryptoModule)
{
    LogRelFlow(("{%p} %s: enter aCryptoModule=%p\n", this, "ExtPackFile::getCryptoModule", aCryptoModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCryptoModule);
        BSTROutConverter TmpCryptoModule(aCryptoModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_CRYPTOMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCryptoModule(TmpCryptoModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_CRYPTOMODULE_RETURN(this, hrc, 0 /*normal*/,TmpCryptoModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_CRYPTOMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_CRYPTOMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCryptoModule=%ls hrc=%Rhrc\n", this, "ExtPackFile::getCryptoModule", !RT_VALID_PTR(aCryptoModule) ? 0 : *aCryptoModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(PlugIns)(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns))
{
    LogRelFlow(("{%p} %s: enter aPlugIns=%p\n", this, "ExtPackFile::getPlugIns", aPlugIns));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugIns);
        ArrayComTypeOutConverter<IExtPackPlugIn> TmpPlugIns(ComSafeArrayOutArg(aPlugIns));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlugIns(TmpPlugIns.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPlugIns.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlugIns=%zu hrc=%Rhrc\n", this, "ExtPackFile::getPlugIns", !RT_VALID_PTR(aPlugIns) ? 0 : ComSafeArraySize(*aPlugIns), hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Usable)(BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aUsable=%p\n", this, "ExtPackFile::getUsable", aUsable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUsable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsable(aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 0 /*normal*/,*aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aUsable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPackFile::getUsable", !RT_VALID_PTR(aUsable) ? 0 : *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(WhyUnusable)(BSTR *aWhyUnusable)
{
    LogRelFlow(("{%p} %s: enter aWhyUnusable=%p\n", this, "ExtPackFile::getWhyUnusable", aWhyUnusable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWhyUnusable);
        BSTROutConverter TmpWhyUnusable(aWhyUnusable);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWhyUnusable(TmpWhyUnusable.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 0 /*normal*/,TmpWhyUnusable.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWhyUnusable=%ls hrc=%Rhrc\n", this, "ExtPackFile::getWhyUnusable", !RT_VALID_PTR(aWhyUnusable) ? 0 : *aWhyUnusable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(ShowLicense)(BOOL *aShowLicense)
{
    LogRelFlow(("{%p} %s: enter aShowLicense=%p\n", this, "ExtPackFile::getShowLicense", aShowLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShowLicense);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShowLicense(aShowLicense);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 0 /*normal*/,*aShowLicense != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 1 /*hrc exception*/,*aShowLicense != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,*aShowLicense != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShowLicense=%RTbool hrc=%Rhrc\n", this, "ExtPackFile::getShowLicense", !RT_VALID_PTR(aShowLicense) ? 0 : *aShowLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(License)(BSTR *aLicense)
{
    LogRelFlow(("{%p} %s: enter aLicense=%p\n", this, "ExtPackFile::getLicense", aLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicense);
        BSTROutConverter TmpLicense(aLicense);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLicense(TmpLicense.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 0 /*normal*/,TmpLicense.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLicense=%ls hrc=%Rhrc\n", this, "ExtPackFile::getLicense", !RT_VALID_PTR(aLicense) ? 0 : *aLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute1IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute2IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute3IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute4IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute5IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute6IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute7IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute8IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IExtPackFile properties
//

STDMETHODIMP ExtPackFileWrap::COMGETTER(FilePath)(BSTR *aFilePath)
{
    LogRelFlow(("{%p} %s: enter aFilePath=%p\n", this, "ExtPackFile::getFilePath", aFilePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilePath);
        BSTROutConverter TmpFilePath(aFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilePath(TmpFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilePath=%ls hrc=%Rhrc\n", this, "ExtPackFile::getFilePath", !RT_VALID_PTR(aFilePath) ? 0 : *aFilePath, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute1IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute2IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute3IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute4IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackBase methods
//

STDMETHODIMP ExtPackFileWrap::QueryLicense(IN_BSTR aPreferredLocale,
                                           IN_BSTR aPreferredLanguage,
                                           IN_BSTR aFormat,
                                           BSTR *aLicenseText)
{
    LogRelFlow(("{%p} %s: enter aPreferredLocale=%ls aPreferredLanguage=%ls aFormat=%ls aLicenseText=%p\n", this, "ExtPackFile::queryLicense", aPreferredLocale, aPreferredLanguage, aFormat, aLicenseText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicenseText);


        BSTRInConverter TmpPreferredLocale(aPreferredLocale);
        BSTRInConverter TmpPreferredLanguage(aPreferredLanguage);
        BSTRInConverter TmpFormat(aFormat);
        BSTROutConverter TmpLicenseText(aLicenseText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_ENTER(this, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryLicense(TmpPreferredLocale.str(),
                               TmpPreferredLanguage.str(),
                               TmpFormat.str(),
                               TmpLicenseText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 0 /*normal*/, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str(), TmpLicenseText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLicenseText=%ls hrc=%Rhrc\n", this, "ExtPackFile::queryLicense", !RT_VALID_PTR(aLicenseText) ? 0 : *aLicenseText, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod1IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod2IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod3IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod4IExtPackBase()
{
    return E_NOTIMPL;
}

//
// IExtPackFile methods
//

STDMETHODIMP ExtPackFileWrap::Install(BOOL aReplace,
                                      IN_BSTR aDisplayInfo,
                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aReplace=%RTbool aDisplayInfo=%ls aProgress=%p\n", this, "ExtPackFile::install", aReplace, aDisplayInfo, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        
        BSTRInConverter TmpDisplayInfo(aDisplayInfo);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_ENTER(this, aReplace != FALSE, TmpDisplayInfo.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = install(aReplace != FALSE,
                          TmpDisplayInfo.str(),
                          TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 0 /*normal*/, aReplace != FALSE, TmpDisplayInfo.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 1 /*hrc exception*/, aReplace != FALSE, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 9 /*unhandled exception*/, aReplace != FALSE, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "ExtPackFile::install", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod1IExtPackFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod2IExtPackFile()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackFileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ExtPackFileWrap, IExtPackFile, IExtPackBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackFileWrap.cpp"


// ##### BEGINFILE "BandwidthControlWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IBandwidthControl.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_BANDWIDTHCONTROL

#include "BandwidthControlWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(BandwidthControlWrap)

//
// IBandwidthControl properties
//

STDMETHODIMP BandwidthControlWrap::COMGETTER(NumGroups)(ULONG *aNumGroups)
{
    LogRelFlow(("{%p} %s: enter aNumGroups=%p\n", this, "BandwidthControl::getNumGroups", aNumGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNumGroups);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNumGroups(aNumGroups);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 0 /*normal*/,*aNumGroups);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 1 /*hrc exception*/,*aNumGroups);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,*aNumGroups);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNumGroups=%RU32 hrc=%Rhrc\n", this, "BandwidthControl::getNumGroups", !RT_VALID_PTR(aNumGroups) ? 0 : *aNumGroups, hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::COMGETTER(InternalAndReservedAttribute1IBandwidthControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthControlWrap::COMGETTER(InternalAndReservedAttribute2IBandwidthControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IBandwidthControl methods
//

STDMETHODIMP BandwidthControlWrap::CreateBandwidthGroup(IN_BSTR aName,
                                                        BandwidthGroupType_T aType,
                                                        LONG64 aMaxBytesPerSec)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aType=%RU32 aMaxBytesPerSec=%RI64\n", this, "BandwidthControl::createBandwidthGroup", aName, aType, aMaxBytesPerSec));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str(), aType, aMaxBytesPerSec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createBandwidthGroup(TmpName.str(),
                                       aType,
                                       aMaxBytesPerSec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aType, aMaxBytesPerSec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aType, aMaxBytesPerSec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aType, aMaxBytesPerSec);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "BandwidthControl::createBandwidthGroup", hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::DeleteBandwidthGroup(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "BandwidthControl::deleteBandwidthGroup", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteBandwidthGroup(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "BandwidthControl::deleteBandwidthGroup", hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::GetBandwidthGroup(IN_BSTR aName,
                                                     IBandwidthGroup **aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aBandwidthGroup=%p\n", this, "BandwidthControl::getBandwidthGroup", aName, aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroup);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBandwidthGroup(TmpName.str(),
                                    TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBandwidthGroup=%p hrc=%Rhrc\n", this, "BandwidthControl::getBandwidthGroup", !RT_VALID_PTR(aBandwidthGroup) ? 0 : *aBandwidthGroup, hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::GetAllBandwidthGroups(ComSafeArrayOut(IBandwidthGroup *, aBandwidthGroups))
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroups=%p\n", this, "BandwidthControl::getAllBandwidthGroups", aBandwidthGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroups);


        ArrayComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroups(ComSafeArrayOutArg(aBandwidthGroups));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllBandwidthGroups(TmpBandwidthGroups.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpBandwidthGroups.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBandwidthGroups=%zu hrc=%Rhrc\n", this, "BandwidthControl::getAllBandwidthGroups", !RT_VALID_PTR(aBandwidthGroups) ? 0 : ComSafeArraySize(*aBandwidthGroups), hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::InternalAndReservedMethod1IBandwidthControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthControlWrap::InternalAndReservedMethod2IBandwidthControl()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(BandwidthControlWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BandwidthControlWrap, IBandwidthControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "BandwidthControlWrap.cpp"


// ##### BEGINFILE "VirtualBoxClientWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVirtualBoxClient.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALBOXCLIENT

#include "VirtualBoxClientWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VirtualBoxClientWrap)

//
// IVirtualBoxClient properties
//

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(VirtualBox)(IVirtualBox **aVirtualBox)
{
    LogRelFlow(("{%p} %s: enter aVirtualBox=%p\n", this, "VirtualBoxClient::getVirtualBox", aVirtualBox));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVirtualBox);
        ComTypeOutConverter<IVirtualBox> TmpVirtualBox(aVirtualBox);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_VIRTUALBOX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVirtualBox(TmpVirtualBox.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_VIRTUALBOX_RETURN(this, hrc, 0 /*normal*/,(void *)TmpVirtualBox.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_VIRTUALBOX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_VIRTUALBOX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVirtualBox=%p hrc=%Rhrc\n", this, "VirtualBoxClient::getVirtualBox", !RT_VALID_PTR(aVirtualBox) ? 0 : *aVirtualBox, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(Session)(ISession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "VirtualBoxClient::getSession", aSession));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSession);
        ComTypeOutConverter<ISession> TmpSession(aSession);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_SESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSession(TmpSession.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_SESSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "VirtualBoxClient::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "VirtualBoxClient::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "VirtualBoxClient::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(InternalAndReservedAttribute1IVirtualBoxClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(InternalAndReservedAttribute2IVirtualBoxClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(InternalAndReservedAttribute3IVirtualBoxClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::COMGETTER(InternalAndReservedAttribute4IVirtualBoxClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVirtualBoxClient methods
//

STDMETHODIMP VirtualBoxClientWrap::CheckMachineError(IMachine *aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "VirtualBoxClient::checkMachineError", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_CHECKMACHINEERROR_ENTER(this, (void *)TmpMachine.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkMachineError(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_CHECKMACHINEERROR_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_CHECKMACHINEERROR_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALBOXCLIENT_CHECKMACHINEERROR_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VirtualBoxClient::checkMachineError", hrc));
    return hrc;
}

STDMETHODIMP VirtualBoxClientWrap::InternalAndReservedMethod1IVirtualBoxClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::InternalAndReservedMethod2IVirtualBoxClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::InternalAndReservedMethod3IVirtualBoxClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualBoxClientWrap::InternalAndReservedMethod4IVirtualBoxClient()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VirtualBoxClientWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VirtualBoxClientWrap, IVirtualBoxClient)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VirtualBoxClientWrap.cpp"


// ##### BEGINFILE "EventSourceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IEventSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_EVENTSOURCE

#include "EventSourceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(EventSourceWrap)

//
// IEventSource properties
//


//
// IEventSource methods
//

STDMETHODIMP EventSourceWrap::CreateListener(IEventListener **aListener)
{
    LogRelFlow(("{%p} %s: enter aListener=%p\n", this, "EventSource::createListener", aListener));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aListener);


        ComTypeOutConverter<IEventListener> TmpListener(aListener);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATELISTENER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createListener(TmpListener.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATELISTENER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpListener.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATELISTENER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATELISTENER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aListener=%p hrc=%Rhrc\n", this, "EventSource::createListener", !RT_VALID_PTR(aListener) ? 0 : *aListener, hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::CreateAggregator(ComSafeArrayIn(IEventSource *, aSubordinates),
                                               IEventSource **aResult)
{
    LogRelFlow(("{%p} %s: enter aSubordinates=%zu aResult=%p\n", this, "EventSource::createAggregator", aSubordinates, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayComTypeInConverter<IEventSource> TmpSubordinates(ComSafeArrayInArg(aSubordinates));
        ComTypeOutConverter<IEventSource> TmpResult(aResult);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATEAGGREGATOR_ENTER(this, (uint32_t)TmpSubordinates.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createAggregator(TmpSubordinates.array(),
                                   TmpResult.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATEAGGREGATOR_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSubordinates.array().size(), NULL /*for now*/, (void *)TmpResult.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATEAGGREGATOR_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_CREATEAGGREGATOR_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%p hrc=%Rhrc\n", this, "EventSource::createAggregator", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::RegisterListener(IEventListener *aListener,
                                               ComSafeArrayIn(VBoxEventType_T, aInteresting),
                                               BOOL aActive)
{
    LogRelFlow(("{%p} %s: enter aListener=%p aInteresting=%zu aActive=%RTbool\n", this, "EventSource::registerListener", aListener, aInteresting, aActive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IEventListener> TmpListener(aListener);
        ArrayInConverter<VBoxEventType_T> TmpInteresting(ComSafeArrayInArg(aInteresting));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_REGISTERLISTENER_ENTER(this, (void *)TmpListener.ptr(), (uint32_t)TmpInteresting.array().size(), NULL /*for now*/, aActive != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = registerListener(TmpListener.ptr(),
                                   TmpInteresting.array(),
                                   aActive != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_REGISTERLISTENER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpListener.ptr(), (uint32_t)TmpInteresting.array().size(), NULL /*for now*/, aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_REGISTERLISTENER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_REGISTERLISTENER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "EventSource::registerListener", hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::UnregisterListener(IEventListener *aListener)
{
    LogRelFlow(("{%p} %s: enter aListener=%p\n", this, "EventSource::unregisterListener", aListener));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IEventListener> TmpListener(aListener);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_UNREGISTERLISTENER_ENTER(this, (void *)TmpListener.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unregisterListener(TmpListener.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_UNREGISTERLISTENER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpListener.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_UNREGISTERLISTENER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_UNREGISTERLISTENER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "EventSource::unregisterListener", hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::FireEvent(IEvent *aEvent,
                                        LONG aTimeout,
                                        BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aEvent=%p aTimeout=%RI32 aResult=%p\n", this, "EventSource::fireEvent", aEvent, aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ComTypeInConverter<IEvent> TmpEvent(aEvent);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_FIREEVENT_ENTER(this, (void *)TmpEvent.ptr(), aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = fireEvent(TmpEvent.ptr(),
                            aTimeout,
                            aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_FIREEVENT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpEvent.ptr(), aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_FIREEVENT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_FIREEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "EventSource::fireEvent", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::GetEvent(IEventListener *aListener,
                                       LONG aTimeout,
                                       IEvent **aEvent)
{
    LogRelFlow(("{%p} %s: enter aListener=%p aTimeout=%RI32 aEvent=%p\n", this, "EventSource::getEvent", aListener, aTimeout, aEvent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEvent);


        ComTypeInConverter<IEventListener> TmpListener(aListener);
        
        ComTypeOutConverter<IEvent> TmpEvent(aEvent);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_GETEVENT_ENTER(this, (void *)TmpListener.ptr(), aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEvent(TmpListener.ptr(),
                           aTimeout,
                           TmpEvent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_GETEVENT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpListener.ptr(), aTimeout, (void *)TmpEvent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_GETEVENT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aTimeout, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_GETEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aTimeout, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aEvent=%p hrc=%Rhrc\n", this, "EventSource::getEvent", !RT_VALID_PTR(aEvent) ? 0 : *aEvent, hrc));
    return hrc;
}

STDMETHODIMP EventSourceWrap::EventProcessed(IEventListener *aListener,
                                             IEvent *aEvent)
{
    LogRelFlow(("{%p} %s: enter aListener=%p aEvent=%p\n", this, "EventSource::eventProcessed", aListener, aEvent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IEventListener> TmpListener(aListener);
        ComTypeInConverter<IEvent> TmpEvent(aEvent);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_EVENTPROCESSED_ENTER(this, (void *)TmpListener.ptr(), (void *)TmpEvent.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = eventProcessed(TmpListener.ptr(),
                                 TmpEvent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_EVENTPROCESSED_RETURN(this, hrc, 0 /*normal*/, (void *)TmpListener.ptr(), (void *)TmpEvent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_EVENTPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTSOURCE_EVENTPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "EventSource::eventProcessed", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(EventSourceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventSourceWrap, IEventSource)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "EventSourceWrap.cpp"


// ##### BEGINFILE "EventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_EVENT

#include "EventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(EventWrap)

//
// IEvent properties
//

STDMETHODIMP EventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "Event::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "Event::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP EventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "Event::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "Event::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP EventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "Event::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "Event::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP EventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Event::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Event::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP EventWrap::WaitProcessed(LONG aTimeout,
                                      BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "Event::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "Event::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(EventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventWrap, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "EventWrap.cpp"


// ##### BEGINFILE "MachineEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMachineEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_MACHINEEVENT

#include "MachineEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MachineEventWrap)

//
// IEvent properties
//

STDMETHODIMP MachineEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "MachineEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "MachineEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP MachineEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "MachineEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "MachineEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP MachineEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "MachineEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "MachineEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IMachineEvent properties
//

STDMETHODIMP MachineEventWrap::COMGETTER(MachineId)(BSTR *aMachineId)
{
    LogRelFlow(("{%p} %s: enter aMachineId=%p\n", this, "MachineEvent::getMachineId", aMachineId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachineId);
        UuidOutConverter TmpMachineId(aMachineId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_MACHINEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachineId(TmpMachineId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_MACHINEID_RETURN(this, hrc, 0 /*normal*/,TmpMachineId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_MACHINEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_GET_MACHINEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachineId=%ls hrc=%Rhrc\n", this, "MachineEvent::getMachineId", !RT_VALID_PTR(aMachineId) ? 0 : *aMachineId, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP MachineEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "MachineEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP MachineEventWrap::WaitProcessed(LONG aTimeout,
                                             BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "MachineEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MACHINEEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "MachineEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IMachineEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MachineEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(MachineEventWrap, IMachineEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MachineEventWrap.cpp"


// ##### BEGINFILE "SnapshotEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISnapshotEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_SNAPSHOTEVENT

#include "SnapshotEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SnapshotEventWrap)

//
// IEvent properties
//

STDMETHODIMP SnapshotEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "SnapshotEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "SnapshotEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP SnapshotEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "SnapshotEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "SnapshotEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP SnapshotEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "SnapshotEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "SnapshotEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IMachineEvent properties
//

STDMETHODIMP SnapshotEventWrap::COMGETTER(MachineId)(BSTR *aMachineId)
{
    LogRelFlow(("{%p} %s: enter aMachineId=%p\n", this, "SnapshotEvent::getMachineId", aMachineId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachineId);
        UuidOutConverter TmpMachineId(aMachineId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_MACHINEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachineId(TmpMachineId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_MACHINEID_RETURN(this, hrc, 0 /*normal*/,TmpMachineId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_MACHINEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_MACHINEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachineId=%ls hrc=%Rhrc\n", this, "SnapshotEvent::getMachineId", !RT_VALID_PTR(aMachineId) ? 0 : *aMachineId, hrc));
    return hrc;
}

//
// ISnapshotEvent properties
//

STDMETHODIMP SnapshotEventWrap::COMGETTER(SnapshotId)(BSTR *aSnapshotId)
{
    LogRelFlow(("{%p} %s: enter aSnapshotId=%p\n", this, "SnapshotEvent::getSnapshotId", aSnapshotId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSnapshotId);
        UuidOutConverter TmpSnapshotId(aSnapshotId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SNAPSHOTID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSnapshotId(TmpSnapshotId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SNAPSHOTID_RETURN(this, hrc, 0 /*normal*/,TmpSnapshotId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SNAPSHOTID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_GET_SNAPSHOTID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSnapshotId=%ls hrc=%Rhrc\n", this, "SnapshotEvent::getSnapshotId", !RT_VALID_PTR(aSnapshotId) ? 0 : *aSnapshotId, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP SnapshotEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "SnapshotEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SnapshotEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP SnapshotEventWrap::WaitProcessed(LONG aTimeout,
                                              BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "SnapshotEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOTEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "SnapshotEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IMachineEvent methods
//

//
// ISnapshotEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SnapshotEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(SnapshotEventWrap, ISnapshotEvent, IMachineEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SnapshotEventWrap.cpp"


// ##### BEGINFILE "ClipboardEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IClipboardEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLIPBOARDEVENT

#include "ClipboardEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ClipboardEventWrap)

//
// IEvent properties
//

STDMETHODIMP ClipboardEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "ClipboardEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "ClipboardEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP ClipboardEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "ClipboardEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "ClipboardEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP ClipboardEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "ClipboardEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "ClipboardEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IClipboardEvent properties
//

STDMETHODIMP ClipboardEventWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "ClipboardEvent::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        BSTROutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "ClipboardEvent::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP ClipboardEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "ClipboardEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ClipboardEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP ClipboardEventWrap::WaitProcessed(LONG aTimeout,
                                               BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "ClipboardEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLIPBOARDEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "ClipboardEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IClipboardEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ClipboardEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ClipboardEventWrap, IClipboardEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ClipboardEventWrap.cpp"


// ##### BEGINFILE "GuestProcessEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestProcessEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTPROCESSEVENT

#include "GuestProcessEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestProcessEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestProcessEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestProcessEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestProcessEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestProcessEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestProcessEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestProcessEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestProcessEvent::getSession", aSession));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSession);
        ComTypeOutConverter<IGuestSession> TmpSession(aSession);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSession(TmpSession.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SESSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestProcessEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

//
// IGuestProcessEvent properties
//

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Process)(IGuestProcess **aProcess)
{
    LogRelFlow(("{%p} %s: enter aProcess=%p\n", this, "GuestProcessEvent::getProcess", aProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProcess);
        ComTypeOutConverter<IGuestProcess> TmpProcess(aProcess);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PROCESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcess(TmpProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PROCESS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PROCESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PROCESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcess=%p hrc=%Rhrc\n", this, "GuestProcessEvent::getProcess", !RT_VALID_PTR(aProcess) ? 0 : *aProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessEventWrap::COMGETTER(Pid)(ULONG *aPid)
{
    LogRelFlow(("{%p} %s: enter aPid=%p\n", this, "GuestProcessEvent::getPid", aPid));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPid);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPid(aPid);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPid);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PID_RETURN(this, hrc, 1 /*hrc exception*/,*aPid);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPid);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPid=%RU32 hrc=%Rhrc\n", this, "GuestProcessEvent::getPid", !RT_VALID_PTR(aPid) ? 0 : *aPid, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestProcessEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestProcessEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestProcessEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestProcessEventWrap::WaitProcessed(LONG aTimeout,
                                                  BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestProcessEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestProcessEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

//
// IGuestProcessEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestProcessEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(GuestProcessEventWrap, IGuestProcessEvent, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestProcessEventWrap.cpp"


// ##### BEGINFILE "GuestDirectoryEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDirectoryEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTDIRECTORYEVENT

#include "GuestDirectoryEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDirectoryEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestDirectoryEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestDirectoryEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestDirectoryEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestDirectoryEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestDirectoryEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestDirectoryEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestDirectoryEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestDirectoryEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestDirectoryEvent::getSession", aSession));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSession);
        ComTypeOutConverter<IGuestSession> TmpSession(aSession);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSession(TmpSession.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SESSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestDirectoryEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

//
// IGuestDirectoryEvent properties
//

STDMETHODIMP GuestDirectoryEventWrap::COMGETTER(Directory)(IGuestDirectory **aDirectory)
{
    LogRelFlow(("{%p} %s: enter aDirectory=%p\n", this, "GuestDirectoryEvent::getDirectory", aDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectory);
        ComTypeOutConverter<IGuestDirectory> TmpDirectory(aDirectory);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_DIRECTORY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDirectory(TmpDirectory.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_DIRECTORY_RETURN(this, hrc, 0 /*normal*/,(void *)TmpDirectory.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_DIRECTORY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_GET_DIRECTORY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectory=%p hrc=%Rhrc\n", this, "GuestDirectoryEvent::getDirectory", !RT_VALID_PTR(aDirectory) ? 0 : *aDirectory, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestDirectoryEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestDirectoryEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDirectoryEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryEventWrap::WaitProcessed(LONG aTimeout,
                                                    BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestDirectoryEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORYEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestDirectoryEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

//
// IGuestDirectoryEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDirectoryEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(GuestDirectoryEventWrap, IGuestDirectoryEvent, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDirectoryEventWrap.cpp"


// ##### BEGINFILE "GuestFileEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFileEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTFILEEVENT

#include "GuestFileEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFileEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestFileEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestFileEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestFileEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestFileEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestFileEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestFileEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestFileEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestFileEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestFileEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestFileEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestFileEvent::getSession", aSession));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSession);
        ComTypeOutConverter<IGuestSession> TmpSession(aSession);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSession(TmpSession.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SESSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestFileEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

//
// IGuestFileEvent properties
//

STDMETHODIMP GuestFileEventWrap::COMGETTER(File)(IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aFile=%p\n", this, "GuestFileEvent::getFile", aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_FILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFile(TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_FILE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_FILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_GET_FILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFile=%p hrc=%Rhrc\n", this, "GuestFileEvent::getFile", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestFileEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestFileEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFileEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestFileEventWrap::WaitProcessed(LONG aTimeout,
                                               BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestFileEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestFileEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

//
// IGuestFileEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFileEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(GuestFileEventWrap, IGuestFileEvent, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFileEventWrap.cpp"


// ##### BEGINFILE "VetoEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVetoEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_VETOEVENT

#include "VetoEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VetoEventWrap)

//
// IEvent properties
//

STDMETHODIMP VetoEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "VetoEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "VetoEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "VetoEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "VetoEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "VetoEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "VetoEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IVetoEvent properties
//


//
// IEvent methods
//

STDMETHODIMP VetoEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "VetoEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::WaitProcessed(LONG aTimeout,
                                          BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "VetoEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IVetoEvent methods
//

STDMETHODIMP VetoEventWrap::AddVeto(IN_BSTR aReason)
{
    LogRelFlow(("{%p} %s: enter aReason=%ls\n", this, "VetoEvent::addVeto", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpReason(aReason);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_ENTER(this, TmpReason.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addVeto(TmpReason.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 0 /*normal*/, TmpReason.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::addVeto", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::IsVetoed(BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "VetoEvent::isVetoed", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isVetoed(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::isVetoed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::GetVetos(ComSafeArrayOut(BSTR, aResult))
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "VetoEvent::getVetos", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayBSTROutConverter TmpResult(ComSafeArrayOutArg(aResult));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVetos(TmpResult.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpResult.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%zu hrc=%Rhrc\n", this, "VetoEvent::getVetos", !RT_VALID_PTR(aResult) ? 0 : ComSafeArraySize(*aResult), hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::AddApproval(IN_BSTR aReason)
{
    LogRelFlow(("{%p} %s: enter aReason=%ls\n", this, "VetoEvent::addApproval", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpReason(aReason);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_ENTER(this, TmpReason.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addApproval(TmpReason.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 0 /*normal*/, TmpReason.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::addApproval", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::IsApproved(BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "VetoEvent::isApproved", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isApproved(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::isApproved", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::GetApprovals(ComSafeArrayOut(BSTR, aResult))
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "VetoEvent::getApprovals", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayBSTROutConverter TmpResult(ComSafeArrayOutArg(aResult));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getApprovals(TmpResult.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpResult.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%zu hrc=%Rhrc\n", this, "VetoEvent::getApprovals", !RT_VALID_PTR(aResult) ? 0 : ComSafeArraySize(*aResult), hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VetoEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(VetoEventWrap, IVetoEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VetoEventWrap.cpp"


// ##### BEGINFILE "ProgressEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IProgressEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_PROGRESSEVENT

#include "ProgressEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ProgressEventWrap)

//
// IEvent properties
//

STDMETHODIMP ProgressEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "ProgressEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "ProgressEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP ProgressEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "ProgressEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "ProgressEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP ProgressEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "ProgressEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "ProgressEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IProgressEvent properties
//

STDMETHODIMP ProgressEventWrap::COMGETTER(ProgressId)(BSTR *aProgressId)
{
    LogRelFlow(("{%p} %s: enter aProgressId=%p\n", this, "ProgressEvent::getProgressId", aProgressId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgressId);
        UuidOutConverter TmpProgressId(aProgressId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_PROGRESSID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProgressId(TmpProgressId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_PROGRESSID_RETURN(this, hrc, 0 /*normal*/,TmpProgressId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_PROGRESSID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_GET_PROGRESSID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProgressId=%ls hrc=%Rhrc\n", this, "ProgressEvent::getProgressId", !RT_VALID_PTR(aProgressId) ? 0 : *aProgressId, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP ProgressEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "ProgressEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ProgressEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP ProgressEventWrap::WaitProcessed(LONG aTimeout,
                                              BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "ProgressEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESSEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "ProgressEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IProgressEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ProgressEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ProgressEventWrap, IProgressEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ProgressEventWrap.cpp"


// ##### BEGINFILE "StringArrayWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IStringArray.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_STRINGARRAY

#include "StringArrayWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(StringArrayWrap)

//
// IStringArray properties
//

STDMETHODIMP StringArrayWrap::COMGETTER(Values)(ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aValues=%p\n", this, "StringArray::getValues", aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGARRAY_GET_VALUES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValues(TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGARRAY_GET_VALUES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGARRAY_GET_VALUES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGARRAY_GET_VALUES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%zu hrc=%Rhrc\n", this, "StringArray::getValues", !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}


//
// IStringArray methods
//

STDMETHODIMP StringArrayWrap::InternalAndReservedMethod1IStringArray()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringArrayWrap::InternalAndReservedMethod2IStringArray()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringArrayWrap::InternalAndReservedMethod3IStringArray()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringArrayWrap::InternalAndReservedMethod4IStringArray()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(StringArrayWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(StringArrayWrap, IStringArray)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "StringArrayWrap.cpp"


// ##### BEGINFILE "FormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_FORMVALUE

#include "FormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP FormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "FormValue::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "FormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "FormValue::getGeneration", aGeneration));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGeneration);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_GENERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aGeneration);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "FormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "FormValue::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "FormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "FormValue::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "FormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "FormValue::getLabel", aLabel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLabel);
        BSTROutConverter TmpLabel(aLabel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_LABEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLabel(TmpLabel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_LABEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "FormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "FormValue::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "FormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "FormValue::getHelp", aHelp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHelp);
        BSTROutConverter TmpHelp(aHelp);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_HELP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHelp(TmpHelp.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_HELP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "FormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP FormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FormValueWrap, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FormValueWrap.cpp"


// ##### BEGINFILE "RangedIntegerFormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IRangedIntegerFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_RANGEDINTEGERFORMVALUE

#include "RangedIntegerFormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(RangedIntegerFormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "RangedIntegerFormValue::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "RangedIntegerFormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "RangedIntegerFormValue::getGeneration", aGeneration));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGeneration);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_GENERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aGeneration);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "RangedIntegerFormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "RangedIntegerFormValue::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "RangedIntegerFormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "RangedIntegerFormValue::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "RangedIntegerFormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "RangedIntegerFormValue::getLabel", aLabel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLabel);
        BSTROutConverter TmpLabel(aLabel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_LABEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLabel(TmpLabel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_LABEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "RangedIntegerFormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "RangedIntegerFormValue::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "RangedIntegerFormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "RangedIntegerFormValue::getHelp", aHelp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHelp);
        BSTROutConverter TmpHelp(aHelp);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_HELP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHelp(TmpHelp.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_HELP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "RangedIntegerFormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IRangedIntegerFormValue properties
//

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Suffix)(BSTR *aSuffix)
{
    LogRelFlow(("{%p} %s: enter aSuffix=%p\n", this, "RangedIntegerFormValue::getSuffix", aSuffix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSuffix);
        BSTROutConverter TmpSuffix(aSuffix);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_SUFFIX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSuffix(TmpSuffix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_SUFFIX_RETURN(this, hrc, 0 /*normal*/,TmpSuffix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_SUFFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_SUFFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSuffix=%ls hrc=%Rhrc\n", this, "RangedIntegerFormValue::getSuffix", !RT_VALID_PTR(aSuffix) ? 0 : *aSuffix, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Minimum)(LONG *aMinimum)
{
    LogRelFlow(("{%p} %s: enter aMinimum=%p\n", this, "RangedIntegerFormValue::getMinimum", aMinimum));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinimum);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MINIMUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinimum(aMinimum);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MINIMUM_RETURN(this, hrc, 0 /*normal*/,*aMinimum);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MINIMUM_RETURN(this, hrc, 1 /*hrc exception*/,*aMinimum);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MINIMUM_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinimum);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinimum=%RI32 hrc=%Rhrc\n", this, "RangedIntegerFormValue::getMinimum", !RT_VALID_PTR(aMinimum) ? 0 : *aMinimum, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(Maximum)(LONG *aMaximum)
{
    LogRelFlow(("{%p} %s: enter aMaximum=%p\n", this, "RangedIntegerFormValue::getMaximum", aMaximum));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaximum);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MAXIMUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaximum(aMaximum);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MAXIMUM_RETURN(this, hrc, 0 /*normal*/,*aMaximum);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MAXIMUM_RETURN(this, hrc, 1 /*hrc exception*/,*aMaximum);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GET_MAXIMUM_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaximum);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaximum=%RI32 hrc=%Rhrc\n", this, "RangedIntegerFormValue::getMaximum", !RT_VALID_PTR(aMaximum) ? 0 : *aMaximum, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute1IRangedIntegerFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute2IRangedIntegerFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute3IRangedIntegerFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::COMGETTER(InternalAndReservedAttribute4IRangedIntegerFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IRangedIntegerFormValue methods
//

STDMETHODIMP RangedIntegerFormValueWrap::GetInteger(LONG *aValue)
{
    LogRelFlow(("{%p} %s: enter aValue=%p\n", this, "RangedIntegerFormValue::getInteger", aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GETINTEGER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInteger(aValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GETINTEGER_RETURN(this, hrc, 0 /*normal*/, *aValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GETINTEGER_RETURN(this, hrc, 1 /*hrc exception*/, *aValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_GETINTEGER_RETURN(this, hrc, 9 /*unhandled exception*/, *aValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%RI32 hrc=%Rhrc\n", this, "RangedIntegerFormValue::getInteger", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::SetInteger(LONG aValue,
                                                    IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aValue=%RI32 aProgress=%p\n", this, "RangedIntegerFormValue::setInteger", aValue, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_SETINTEGER_ENTER(this, aValue);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInteger(aValue,
                             TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_SETINTEGER_RETURN(this, hrc, 0 /*normal*/, aValue, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_SETINTEGER_RETURN(this, hrc, 1 /*hrc exception*/, aValue, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGERFORMVALUE_SETINTEGER_RETURN(this, hrc, 9 /*unhandled exception*/, aValue, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "RangedIntegerFormValue::setInteger", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod1IRangedIntegerFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod2IRangedIntegerFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod3IRangedIntegerFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedIntegerFormValueWrap::InternalAndReservedMethod4IRangedIntegerFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(RangedIntegerFormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RangedIntegerFormValueWrap, IRangedIntegerFormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "RangedIntegerFormValueWrap.cpp"


// ##### BEGINFILE "StringFormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IStringFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_STRINGFORMVALUE

#include "StringFormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(StringFormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP StringFormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "StringFormValue::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "StringFormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "StringFormValue::getGeneration", aGeneration));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGeneration);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aGeneration);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "StringFormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "StringFormValue::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "StringFormValue::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "StringFormValue::getLabel", aLabel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLabel);
        BSTROutConverter TmpLabel(aLabel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLabel(TmpLabel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "StringFormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "StringFormValue::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "StringFormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "StringFormValue::getHelp", aHelp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHelp);
        BSTROutConverter TmpHelp(aHelp);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHelp(TmpHelp.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "StringFormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IStringFormValue properties
//

STDMETHODIMP StringFormValueWrap::COMGETTER(Multiline)(BOOL *aMultiline)
{
    LogRelFlow(("{%p} %s: enter aMultiline=%p\n", this, "StringFormValue::getMultiline", aMultiline));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMultiline);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMultiline(aMultiline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 0 /*normal*/,*aMultiline != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 1 /*hrc exception*/,*aMultiline != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMultiline != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMultiline=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getMultiline", !RT_VALID_PTR(aMultiline) ? 0 : *aMultiline, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(ClipboardString)(BSTR *aClipboardString)
{
    LogRelFlow(("{%p} %s: enter aClipboardString=%p\n", this, "StringFormValue::getClipboardString", aClipboardString));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClipboardString);
        BSTROutConverter TmpClipboardString(aClipboardString);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_CLIPBOARDSTRING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClipboardString(TmpClipboardString.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_CLIPBOARDSTRING_RETURN(this, hrc, 0 /*normal*/,TmpClipboardString.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_CLIPBOARDSTRING_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_CLIPBOARDSTRING_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClipboardString=%ls hrc=%Rhrc\n", this, "StringFormValue::getClipboardString", !RT_VALID_PTR(aClipboardString) ? 0 : *aClipboardString, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute1IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute2IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute3IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute4IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IStringFormValue methods
//

STDMETHODIMP StringFormValueWrap::GetString(BSTR *aText)
{
    LogRelFlow(("{%p} %s: enter aText=%p\n", this, "StringFormValue::getString", aText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aText);


        BSTROutConverter TmpText(aText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getString(TmpText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 0 /*normal*/, TmpText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aText=%ls hrc=%Rhrc\n", this, "StringFormValue::getString", !RT_VALID_PTR(aText) ? 0 : *aText, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::SetString(IN_BSTR aText,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aText=%ls aProgress=%p\n", this, "StringFormValue::setString", aText, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpText(aText);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_ENTER(this, TmpText.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setString(TmpText.str(),
                            TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 0 /*normal*/, TmpText.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "StringFormValue::setString", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod1IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod2IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod3IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod4IStringFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(StringFormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(StringFormValueWrap, IStringFormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "StringFormValueWrap.cpp"


// ##### BEGINFILE "FormWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IForm.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_FORM

#include "FormWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FormWrap)

//
// IForm properties
//

STDMETHODIMP FormWrap::COMGETTER(Values)(ComSafeArrayOut(IFormValue *, aValues))
{
    LogRelFlow(("{%p} %s: enter aValues=%p\n", this, "Form::getValues", aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);
        ArrayComTypeOutConverter<IFormValue> TmpValues(ComSafeArrayOutArg(aValues));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValues(TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%zu hrc=%Rhrc\n", this, "Form::getValues", !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute1IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute2IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute3IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute4IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IForm methods
//

STDMETHODIMP FormWrap::GetFieldGroup(IN_BSTR aField,
                                     ComSafeArrayOut(BSTR, aGroup))
{
    LogRelFlow(("{%p} %s: enter aField=%ls aGroup=%p\n", this, "Form::getFieldGroup", aField, aGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroup);


        BSTRInConverter TmpField(aField);
        ArrayBSTROutConverter TmpGroup(ComSafeArrayOutArg(aGroup));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GETFIELDGROUP_ENTER(this, TmpField.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFieldGroup(TmpField.str(),
                                TmpGroup.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GETFIELDGROUP_RETURN(this, hrc, 0 /*normal*/, TmpField.str().c_str(), (uint32_t)TmpGroup.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GETFIELDGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GETFIELDGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGroup=%zu hrc=%Rhrc\n", this, "Form::getFieldGroup", !RT_VALID_PTR(aGroup) ? 0 : ComSafeArraySize(*aGroup), hrc));
    return hrc;
}

STDMETHODIMP FormWrap::Apply(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Form::apply", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_APPLY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = apply(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_APPLY_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_APPLY_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_APPLY_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Form::apply", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod1IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod2IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod3IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod4IForm()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FormWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FormWrap, IForm)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FormWrap.cpp"


// ##### BEGINFILE "CloudNetworkGatewayInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudNetworkGatewayInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDNETWORKGATEWAYINFO

#include "CloudNetworkGatewayInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudNetworkGatewayInfoWrap)

//
// ICloudNetworkGatewayInfo properties
//

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(PublicIP)(BSTR *aPublicIP)
{
    LogRelFlow(("{%p} %s: enter aPublicIP=%p\n", this, "CloudNetworkGatewayInfo::getPublicIP", aPublicIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPublicIP);
        BSTROutConverter TmpPublicIP(aPublicIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPublicIP(TmpPublicIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 0 /*normal*/,TmpPublicIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPublicIP=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getPublicIP", !RT_VALID_PTR(aPublicIP) ? 0 : *aPublicIP, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(SecondaryPublicIP)(BSTR *aSecondaryPublicIP)
{
    LogRelFlow(("{%p} %s: enter aSecondaryPublicIP=%p\n", this, "CloudNetworkGatewayInfo::getSecondaryPublicIP", aSecondaryPublicIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSecondaryPublicIP);
        BSTROutConverter TmpSecondaryPublicIP(aSecondaryPublicIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSecondaryPublicIP(TmpSecondaryPublicIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 0 /*normal*/,TmpSecondaryPublicIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSecondaryPublicIP=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getSecondaryPublicIP", !RT_VALID_PTR(aSecondaryPublicIP) ? 0 : *aSecondaryPublicIP, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(MacAddress)(BSTR *aMacAddress)
{
    LogRelFlow(("{%p} %s: enter aMacAddress=%p\n", this, "CloudNetworkGatewayInfo::getMacAddress", aMacAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMacAddress);
        BSTROutConverter TmpMacAddress(aMacAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMacAddress(TmpMacAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpMacAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMacAddress=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getMacAddress", !RT_VALID_PTR(aMacAddress) ? 0 : *aMacAddress, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InstanceId)(BSTR *aInstanceId)
{
    LogRelFlow(("{%p} %s: enter aInstanceId=%p\n", this, "CloudNetworkGatewayInfo::getInstanceId", aInstanceId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInstanceId);
        BSTROutConverter TmpInstanceId(aInstanceId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstanceId(TmpInstanceId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 0 /*normal*/,TmpInstanceId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInstanceId=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getInstanceId", !RT_VALID_PTR(aInstanceId) ? 0 : *aInstanceId, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute1ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute2ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute3ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute4ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute5ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudNetworkGatewayInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudNetworkGatewayInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudNetworkGatewayInfoWrap, ICloudNetworkGatewayInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudNetworkGatewayInfoWrap.cpp"


// ##### BEGINFILE "CloudMachineWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudMachine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDMACHINE

#include "CloudMachineWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudMachineWrap)

//
// ICloudMachine properties
//

STDMETHODIMP CloudMachineWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "CloudMachine::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "CloudMachine::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(CloudId)(BSTR *aCloudId)
{
    LogRelFlow(("{%p} %s: enter aCloudId=%p\n", this, "CloudMachine::getCloudId", aCloudId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudId);
        BSTROutConverter TmpCloudId(aCloudId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CLOUDID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudId(TmpCloudId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CLOUDID_RETURN(this, hrc, 0 /*normal*/,TmpCloudId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CLOUDID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CLOUDID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudId=%ls hrc=%Rhrc\n", this, "CloudMachine::getCloudId", !RT_VALID_PTR(aCloudId) ? 0 : *aCloudId, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(Accessible)(BOOL *aAccessible)
{
    LogRelFlow(("{%p} %s: enter aAccessible=%p\n", this, "CloudMachine::getAccessible", aAccessible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSIBLE_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessible(aAccessible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 0 /*normal*/,*aAccessible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessible=%RTbool hrc=%Rhrc\n", this, "CloudMachine::getAccessible", !RT_VALID_PTR(aAccessible) ? 0 : *aAccessible, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(AccessError)(IVirtualBoxErrorInfo **aAccessError)
{
    LogRelFlow(("{%p} %s: enter aAccessError=%p\n", this, "CloudMachine::getAccessError", aAccessError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessError);
        ComTypeOutConverter<IVirtualBoxErrorInfo> TmpAccessError(aAccessError);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSERROR_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessError(TmpAccessError.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSERROR_RETURN(this, hrc, 0 /*normal*/,(void *)TmpAccessError.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSERROR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_ACCESSERROR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessError=%p hrc=%Rhrc\n", this, "CloudMachine::getAccessError", !RT_VALID_PTR(aAccessError) ? 0 : *aAccessError, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CloudMachine::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CloudMachine::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
{
    LogRelFlow(("{%p} %s: enter aOSTypeId=%p\n", this, "CloudMachine::getOSTypeId", aOSTypeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOSTypeId);
        BSTROutConverter TmpOSTypeId(aOSTypeId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_OSTYPEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOSTypeId(TmpOSTypeId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_OSTYPEID_RETURN(this, hrc, 0 /*normal*/,TmpOSTypeId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_OSTYPEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_OSTYPEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOSTypeId=%ls hrc=%Rhrc\n", this, "CloudMachine::getOSTypeId", !RT_VALID_PTR(aOSTypeId) ? 0 : *aOSTypeId, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(State)(CloudMachineState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "CloudMachine::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "CloudMachine::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(ConsoleConnectionFingerprint)(BSTR *aConsoleConnectionFingerprint)
{
    LogRelFlow(("{%p} %s: enter aConsoleConnectionFingerprint=%p\n", this, "CloudMachine::getConsoleConnectionFingerprint", aConsoleConnectionFingerprint));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConsoleConnectionFingerprint);
        BSTROutConverter TmpConsoleConnectionFingerprint(aConsoleConnectionFingerprint);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CONSOLECONNECTIONFINGERPRINT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConsoleConnectionFingerprint(TmpConsoleConnectionFingerprint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CONSOLECONNECTIONFINGERPRINT_RETURN(this, hrc, 0 /*normal*/,TmpConsoleConnectionFingerprint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CONSOLECONNECTIONFINGERPRINT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_CONSOLECONNECTIONFINGERPRINT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aConsoleConnectionFingerprint=%ls hrc=%Rhrc\n", this, "CloudMachine::getConsoleConnectionFingerprint", !RT_VALID_PTR(aConsoleConnectionFingerprint) ? 0 : *aConsoleConnectionFingerprint, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(SerialConsoleCommand)(BSTR *aSerialConsoleCommand)
{
    LogRelFlow(("{%p} %s: enter aSerialConsoleCommand=%p\n", this, "CloudMachine::getSerialConsoleCommand", aSerialConsoleCommand));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialConsoleCommand);
        BSTROutConverter TmpSerialConsoleCommand(aSerialConsoleCommand);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMAND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialConsoleCommand(TmpSerialConsoleCommand.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMAND_RETURN(this, hrc, 0 /*normal*/,TmpSerialConsoleCommand.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMAND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialConsoleCommand=%ls hrc=%Rhrc\n", this, "CloudMachine::getSerialConsoleCommand", !RT_VALID_PTR(aSerialConsoleCommand) ? 0 : *aSerialConsoleCommand, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(SerialConsoleCommandWindows)(BSTR *aSerialConsoleCommandWindows)
{
    LogRelFlow(("{%p} %s: enter aSerialConsoleCommandWindows=%p\n", this, "CloudMachine::getSerialConsoleCommandWindows", aSerialConsoleCommandWindows));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSerialConsoleCommandWindows);
        BSTROutConverter TmpSerialConsoleCommandWindows(aSerialConsoleCommandWindows);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMANDWINDOWS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialConsoleCommandWindows(TmpSerialConsoleCommandWindows.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 0 /*normal*/,TmpSerialConsoleCommandWindows.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_SERIALCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialConsoleCommandWindows=%ls hrc=%Rhrc\n", this, "CloudMachine::getSerialConsoleCommandWindows", !RT_VALID_PTR(aSerialConsoleCommandWindows) ? 0 : *aSerialConsoleCommandWindows, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(VNCConsoleCommand)(BSTR *aVNCConsoleCommand)
{
    LogRelFlow(("{%p} %s: enter aVNCConsoleCommand=%p\n", this, "CloudMachine::getVNCConsoleCommand", aVNCConsoleCommand));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVNCConsoleCommand);
        BSTROutConverter TmpVNCConsoleCommand(aVNCConsoleCommand);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMAND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVNCConsoleCommand(TmpVNCConsoleCommand.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMAND_RETURN(this, hrc, 0 /*normal*/,TmpVNCConsoleCommand.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMAND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVNCConsoleCommand=%ls hrc=%Rhrc\n", this, "CloudMachine::getVNCConsoleCommand", !RT_VALID_PTR(aVNCConsoleCommand) ? 0 : *aVNCConsoleCommand, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(VNCConsoleCommandWindows)(BSTR *aVNCConsoleCommandWindows)
{
    LogRelFlow(("{%p} %s: enter aVNCConsoleCommandWindows=%p\n", this, "CloudMachine::getVNCConsoleCommandWindows", aVNCConsoleCommandWindows));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVNCConsoleCommandWindows);
        BSTROutConverter TmpVNCConsoleCommandWindows(aVNCConsoleCommandWindows);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMANDWINDOWS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVNCConsoleCommandWindows(TmpVNCConsoleCommandWindows.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 0 /*normal*/,TmpVNCConsoleCommandWindows.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GET_VNCCONSOLECOMMANDWINDOWS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVNCConsoleCommandWindows=%ls hrc=%Rhrc\n", this, "CloudMachine::getVNCConsoleCommandWindows", !RT_VALID_PTR(aVNCConsoleCommandWindows) ? 0 : *aVNCConsoleCommandWindows, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute1ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute2ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute3ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute4ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute5ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute6ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::COMGETTER(InternalAndReservedAttribute7ICloudMachine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudMachine methods
//

STDMETHODIMP CloudMachineWrap::Refresh(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::refresh", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REFRESH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = refresh(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REFRESH_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REFRESH_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REFRESH_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::refresh", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::GetDetailsForm(IForm **aForm)
{
    LogRelFlow(("{%p} %s: enter aForm=%p\n", this, "CloudMachine::getDetailsForm", aForm));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aForm);


        ComTypeOutConverter<IForm> TmpForm(aForm);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETDETAILSFORM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetailsForm(TmpForm.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETDETAILSFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpForm.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETDETAILSFORM_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETDETAILSFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aForm=%p hrc=%Rhrc\n", this, "CloudMachine::getDetailsForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::GetSettingsForm(IForm **aForm,
                                               IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aForm=%p aProgress=%p\n", this, "CloudMachine::getSettingsForm", aForm, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aForm);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IForm> TmpForm(aForm);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETSETTINGSFORM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSettingsForm(TmpForm.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETSETTINGSFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpForm.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETSETTINGSFORM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETSETTINGSFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForm=%p aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::getSettingsForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::PowerUp(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::powerUp", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerUp(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERUP_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::powerUp", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Reboot(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::reboot", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REBOOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reboot(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REBOOT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REBOOT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REBOOT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::reboot", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Reset(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::reset", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_RESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reset(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_RESET_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_RESET_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_RESET_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::reset", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Shutdown(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::shutdown", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_SHUTDOWN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = shutdown(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_SHUTDOWN_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_SHUTDOWN_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_SHUTDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::shutdown", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::PowerDown(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::powerDown", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERDOWN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerDown(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERDOWN_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERDOWN_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_POWERDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::powerDown", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Terminate(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::terminate", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_TERMINATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = terminate(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_TERMINATE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_TERMINATE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_TERMINATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::terminate", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Unregister(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::unregister", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_UNREGISTER_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = unregister(autoCaller,
                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_UNREGISTER_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_UNREGISTER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_UNREGISTER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::unregister", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::Remove(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::remove", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REMOVE_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove(autoCaller,
                     TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REMOVE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::remove", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::GetConsoleHistory(IDataStream **aStream,
                                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aStream=%p aProgress=%p\n", this, "CloudMachine::getConsoleHistory", aStream, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStream);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IDataStream> TmpStream(aStream);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETCONSOLEHISTORY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConsoleHistory(TmpStream.ptr(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETCONSOLEHISTORY_RETURN(this, hrc, 0 /*normal*/, (void *)TmpStream.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETCONSOLEHISTORY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_GETCONSOLEHISTORY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStream=%p aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::getConsoleHistory", !RT_VALID_PTR(aStream) ? 0 : *aStream, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::CreateConsoleConnection(IN_BSTR aSshPublicKey,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSshPublicKey=%ls aProgress=%p\n", this, "CloudMachine::createConsoleConnection", aSshPublicKey, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSshPublicKey(aSshPublicKey);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_CREATECONSOLECONNECTION_ENTER(this, TmpSshPublicKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createConsoleConnection(TmpSshPublicKey.str(),
                                          TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_CREATECONSOLECONNECTION_RETURN(this, hrc, 0 /*normal*/, TmpSshPublicKey.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_CREATECONSOLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_CREATECONSOLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::createConsoleConnection", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::DeleteConsoleConnection(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudMachine::deleteConsoleConnection", aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_DELETECONSOLECONNECTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteConsoleConnection(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_DELETECONSOLECONNECTION_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_DELETECONSOLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_DELETECONSOLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::deleteConsoleConnection", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::ListMetricNames(IStringArray **aMetricNames,
                                               IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%p aProgress=%p\n", this, "CloudMachine::listMetricNames", aMetricNames, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMetricNames);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IStringArray> TmpMetricNames(aMetricNames);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_LISTMETRICNAMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listMetricNames(TmpMetricNames.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_LISTMETRICNAMES_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMetricNames.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_LISTMETRICNAMES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_LISTMETRICNAMES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMetricNames=%p aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::listMetricNames", !RT_VALID_PTR(aMetricNames) ? 0 : *aMetricNames, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::EnumerateMetricData(MetricType_T aMetricType,
                                                   ULONG aPointsNumber,
                                                   IStringArray **aValues,
                                                   IStringArray **aTimestamps,
                                                   IStringArray **aUnit,
                                                   IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aMetricType=%RU32 aPointsNumber=%RU32 aValues=%p aTimestamps=%p aUnit=%p aProgress=%p\n", this, "CloudMachine::enumerateMetricData", aMetricType, aPointsNumber, aValues, aTimestamps, aUnit, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);
        CheckComArgOutPointerValidThrow(aTimestamps);
        CheckComArgOutPointerValidThrow(aUnit);
        CheckComArgOutPointerValidThrow(aProgress);


        
        
        ComTypeOutConverter<IStringArray> TmpValues(aValues);
        ComTypeOutConverter<IStringArray> TmpTimestamps(aTimestamps);
        ComTypeOutConverter<IStringArray> TmpUnit(aUnit);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_ENUMERATEMETRICDATA_ENTER(this, aMetricType, aPointsNumber);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enumerateMetricData(aMetricType,
                                      aPointsNumber,
                                      TmpValues.ptr(),
                                      TmpTimestamps.ptr(),
                                      TmpUnit.ptr(),
                                      TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_ENUMERATEMETRICDATA_RETURN(this, hrc, 0 /*normal*/, aMetricType, aPointsNumber, (void *)TmpValues.ptr(), (void *)TmpTimestamps.ptr(), (void *)TmpUnit.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_ENUMERATEMETRICDATA_RETURN(this, hrc, 1 /*hrc exception*/, aMetricType, aPointsNumber, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDMACHINE_ENUMERATEMETRICDATA_RETURN(this, hrc, 9 /*unhandled exception*/, aMetricType, aPointsNumber, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%p *aTimestamps=%p *aUnit=%p aProgress=%p hrc=%Rhrc\n", this, "CloudMachine::enumerateMetricData", !RT_VALID_PTR(aValues) ? 0 : *aValues, !RT_VALID_PTR(aTimestamps) ? 0 : *aTimestamps, !RT_VALID_PTR(aUnit) ? 0 : *aUnit, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod1ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod2ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod3ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod4ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod5ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod6ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod7ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod8ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod9ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod10ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod11ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod12ICloudMachine()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudMachineWrap::InternalAndReservedMethod13ICloudMachine()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudMachineWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudMachineWrap, ICloudMachine)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudMachineWrap.cpp"


// ##### BEGINFILE "CloudProfileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudProfile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDPROFILE

#include "CloudProfileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudProfileWrap)

//
// ICloudProfile properties
//

STDMETHODIMP CloudProfileWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CloudProfile::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CloudProfile::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "CloudProfile::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfile::setName", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(ProviderId)(BSTR *aProviderId)
{
    LogRelFlow(("{%p} %s: enter aProviderId=%p\n", this, "CloudProfile::getProviderId", aProviderId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProviderId);
        UuidOutConverter TmpProviderId(aProviderId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_PROVIDERID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviderId(TmpProviderId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_PROVIDERID_RETURN(this, hrc, 0 /*normal*/,TmpProviderId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_PROVIDERID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GET_PROVIDERID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProviderId=%ls hrc=%Rhrc\n", this, "CloudProfile::getProviderId", !RT_VALID_PTR(aProviderId) ? 0 : *aProviderId, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute1ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute2ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute3ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute4ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute5ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute6ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute7ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::COMGETTER(InternalAndReservedAttribute8ICloudProfile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudProfile methods
//

STDMETHODIMP CloudProfileWrap::GetProperty(IN_BSTR aName,
                                           BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%p\n", this, "CloudProfile::getProperty", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTY_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperty(TmpName.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "CloudProfile::getProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::SetProperty(IN_BSTR aName,
                                           IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%ls\n", this, "CloudProfile::setProperty", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTY_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProperty(TmpName.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfile::setProperty", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::GetProperties(IN_BSTR aNames,
                                             ComSafeArrayOut(BSTR, aReturnNames),
                                             ComSafeArrayOut(BSTR, aReturnValues))
{
    LogRelFlow(("{%p} %s: enter aNames=%ls aReturnNames=%p aReturnValues=%p\n", this, "CloudProfile::getProperties", aNames, aReturnNames, aReturnValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnValues);


        BSTRInConverter TmpNames(aNames);
        ArrayBSTROutConverter TmpReturnNames(ComSafeArrayOutArg(aReturnNames));
        ArrayBSTROutConverter TmpReturnValues(ComSafeArrayOutArg(aReturnValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTIES_ENTER(this, TmpNames.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperties(TmpNames.str(),
                                TmpReturnNames.array(),
                                TmpReturnValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTIES_RETURN(this, hrc, 0 /*normal*/, TmpNames.str().c_str(), (uint32_t)TmpReturnNames.array().size(), NULL /*for now*/, (uint32_t)TmpReturnValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_GETPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%zu aReturnValues=%zu hrc=%Rhrc\n", this, "CloudProfile::getProperties", !RT_VALID_PTR(aReturnNames) ? 0 : ComSafeArraySize(*aReturnNames), !RT_VALID_PTR(aReturnValues) ? 0 : ComSafeArraySize(*aReturnValues), hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::SetProperties(ComSafeArrayIn(IN_BSTR, aNames),
                                             ComSafeArrayIn(IN_BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aNames=%zu aValues=%zu\n", this, "CloudProfile::setProperties", aNames, aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpNames(ComSafeArrayInArg(aNames));
        ArrayBSTRInConverter TmpValues(ComSafeArrayInArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTIES_ENTER(this, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProperties(TmpNames.array(),
                                TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTIES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_SETPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfile::setProperties", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProfile::remove"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfile::remove", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::CreateCloudClient(ICloudClient **aCloudClient)
{
    LogRelFlow(("{%p} %s: enter aCloudClient=%p\n", this, "CloudProfile::createCloudClient", aCloudClient));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudClient);


        ComTypeOutConverter<ICloudClient> TmpCloudClient(aCloudClient);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_CREATECLOUDCLIENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createCloudClient(TmpCloudClient.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_CREATECLOUDCLIENT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpCloudClient.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_CREATECLOUDCLIENT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILE_CREATECLOUDCLIENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCloudClient=%p hrc=%Rhrc\n", this, "CloudProfile::createCloudClient", !RT_VALID_PTR(aCloudClient) ? 0 : *aCloudClient, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileWrap::InternalAndReservedMethod1ICloudProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::InternalAndReservedMethod2ICloudProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::InternalAndReservedMethod3ICloudProfile()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProfileWrap::InternalAndReservedMethod4ICloudProfile()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudProfileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudProfileWrap, ICloudProfile)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudProfileWrap.cpp"


// ##### BEGINFILE "CloudProviderManagerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudProviderManager.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDPROVIDERMANAGER

#include "CloudProviderManagerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudProviderManagerWrap)

//
// ICloudProviderManager properties
//

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(Providers)(ComSafeArrayOut(ICloudProvider *, aProviders))
{
    LogRelFlow(("{%p} %s: enter aProviders=%p\n", this, "CloudProviderManager::getProviders", aProviders));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProviders);
        ArrayComTypeOutConverter<ICloudProvider> TmpProviders(ComSafeArrayOutArg(aProviders));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GET_PROVIDERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviders(TmpProviders.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GET_PROVIDERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProviders.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GET_PROVIDERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GET_PROVIDERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProviders=%zu hrc=%Rhrc\n", this, "CloudProviderManager::getProviders", !RT_VALID_PTR(aProviders) ? 0 : ComSafeArraySize(*aProviders), hrc));
    return hrc;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute1ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute2ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute3ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute4ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute5ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute6ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute7ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::COMGETTER(InternalAndReservedAttribute8ICloudProviderManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudProviderManager methods
//

STDMETHODIMP CloudProviderManagerWrap::GetProviderById(IN_BSTR aProviderId,
                                                       ICloudProvider **aProvider)
{
    LogRelFlow(("{%p} %s: enter aProviderId=%ls aProvider=%p\n", this, "CloudProviderManager::getProviderById", aProviderId, aProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProvider);


        UuidInConverter TmpProviderId(aProviderId);
        ComTypeOutConverter<ICloudProvider> TmpProvider(aProvider);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYID_ENTER(this, TmpProviderId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviderById(TmpProviderId.uuid(),
                                  TmpProvider.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYID_RETURN(this, hrc, 0 /*normal*/, TmpProviderId.uuid().toStringCurly().c_str(), (void *)TmpProvider.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYID_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYID_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProvider=%p hrc=%Rhrc\n", this, "CloudProviderManager::getProviderById", !RT_VALID_PTR(aProvider) ? 0 : *aProvider, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderManagerWrap::GetProviderByShortName(IN_BSTR aProviderName,
                                                              ICloudProvider **aProvider)
{
    LogRelFlow(("{%p} %s: enter aProviderName=%ls aProvider=%p\n", this, "CloudProviderManager::getProviderByShortName", aProviderName, aProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProvider);


        BSTRInConverter TmpProviderName(aProviderName);
        ComTypeOutConverter<ICloudProvider> TmpProvider(aProvider);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYSHORTNAME_ENTER(this, TmpProviderName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviderByShortName(TmpProviderName.str(),
                                         TmpProvider.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYSHORTNAME_RETURN(this, hrc, 0 /*normal*/, TmpProviderName.str().c_str(), (void *)TmpProvider.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYSHORTNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYSHORTNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProvider=%p hrc=%Rhrc\n", this, "CloudProviderManager::getProviderByShortName", !RT_VALID_PTR(aProvider) ? 0 : *aProvider, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderManagerWrap::GetProviderByName(IN_BSTR aProviderName,
                                                         ICloudProvider **aProvider)
{
    LogRelFlow(("{%p} %s: enter aProviderName=%ls aProvider=%p\n", this, "CloudProviderManager::getProviderByName", aProviderName, aProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProvider);


        BSTRInConverter TmpProviderName(aProviderName);
        ComTypeOutConverter<ICloudProvider> TmpProvider(aProvider);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYNAME_ENTER(this, TmpProviderName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviderByName(TmpProviderName.str(),
                                    TmpProvider.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpProviderName.str().c_str(), (void *)TmpProvider.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDERMANAGER_GETPROVIDERBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProvider=%p hrc=%Rhrc\n", this, "CloudProviderManager::getProviderByName", !RT_VALID_PTR(aProvider) ? 0 : *aProvider, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderManagerWrap::InternalAndReservedMethod1ICloudProviderManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::InternalAndReservedMethod2ICloudProviderManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::InternalAndReservedMethod3ICloudProviderManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderManagerWrap::InternalAndReservedMethod4ICloudProviderManager()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudProviderManagerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudProviderManagerWrap, ICloudProviderManager)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudProviderManagerWrap.cpp"


// ##### BEGINFILE "CloudProfileRegisteredEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudProfileRegisteredEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDPROFILEREGISTEREDEVENT

#include "CloudProfileRegisteredEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudProfileRegisteredEventWrap)

//
// IEvent properties
//

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "CloudProfileRegisteredEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "CloudProfileRegisteredEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "CloudProfileRegisteredEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// ICloudProfileRegisteredEvent properties
//

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(ProviderId)(BSTR *aProviderId)
{
    LogRelFlow(("{%p} %s: enter aProviderId=%p\n", this, "CloudProfileRegisteredEvent::getProviderId", aProviderId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProviderId);
        UuidOutConverter TmpProviderId(aProviderId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_PROVIDERID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProviderId(TmpProviderId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_PROVIDERID_RETURN(this, hrc, 0 /*normal*/,TmpProviderId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_PROVIDERID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_PROVIDERID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProviderId=%ls hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getProviderId", !RT_VALID_PTR(aProviderId) ? 0 : *aProviderId, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CloudProfileRegisteredEvent::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileRegisteredEventWrap::COMGETTER(Registered)(BOOL *aRegistered)
{
    LogRelFlow(("{%p} %s: enter aRegistered=%p\n", this, "CloudProfileRegisteredEvent::getRegistered", aRegistered));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRegistered);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_REGISTERED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRegistered(aRegistered);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_REGISTERED_RETURN(this, hrc, 0 /*normal*/,*aRegistered != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_REGISTERED_RETURN(this, hrc, 1 /*hrc exception*/,*aRegistered != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_GET_REGISTERED_RETURN(this, hrc, 9 /*unhandled exception*/,*aRegistered != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRegistered=%RTbool hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::getRegistered", !RT_VALID_PTR(aRegistered) ? 0 : *aRegistered, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP CloudProfileRegisteredEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProfileRegisteredEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileRegisteredEventWrap::WaitProcessed(LONG aTimeout,
                                                            BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "CloudProfileRegisteredEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILEREGISTEREDEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "CloudProfileRegisteredEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// ICloudProfileRegisteredEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudProfileRegisteredEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(CloudProfileRegisteredEventWrap, ICloudProfileRegisteredEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudProfileRegisteredEventWrap.cpp"
