

// ##### BEGINFILE "NATNetworkWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for INATNetwork.
 *
 * 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_NATNETWORK

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

DEFINE_EMPTY_CTOR_DTOR(NATNetworkWrap)

//
// INATNetwork properties
//

STDMETHODIMP NATNetworkWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(NetworkName)(IN_BSTR aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "NATNetwork::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_NATNETWORK_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(Network)(BSTR *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_GET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(Network)(IN_BSTR aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%ls\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(Gateway)(BSTR *aGateway)
{
    LogRelFlow(("{%p} %s: enter aGateway=%p\n", this, "NATNetwork::getGateway", aGateway));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGateway);
        BSTROutConverter TmpGateway(aGateway);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_GATEWAY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGateway(TmpGateway.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_GATEWAY_RETURN(this, hrc, 0 /*normal*/,TmpGateway.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_GATEWAY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_GATEWAY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(IPv6Enabled)(BOOL *aIPv6Enabled)
{
    LogRelFlow(("{%p} %s: enter aIPv6Enabled=%p\n", this, "NATNetwork::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_NATNETWORK_GET_IPV6ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIPv6Enabled(aIPv6Enabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_IPV6ENABLED_RETURN(this, hrc, 0 /*normal*/,*aIPv6Enabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_IPV6ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIPv6Enabled != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(IPv6Enabled)(BOOL aIPv6Enabled)
{
    LogRelFlow(("{%p} %s: enter aIPv6Enabled=%RTbool\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_IPV6ENABLED_RETURN(this, hrc, 0 /*normal*/,aIPv6Enabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_IPV6ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aIPv6Enabled != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(IPv6Prefix)(BSTR *aIPv6Prefix)
{
    LogRelFlow(("{%p} %s: enter aIPv6Prefix=%p\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_GET_IPV6PREFIX_RETURN(this, hrc, 0 /*normal*/,TmpIPv6Prefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_IPV6PREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(IPv6Prefix)(IN_BSTR aIPv6Prefix)
{
    LogRelFlow(("{%p} %s: enter aIPv6Prefix=%ls\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_IPV6PREFIX_RETURN(this, hrc, 0 /*normal*/,TmpIPv6Prefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_IPV6PREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL *aAdvertiseDefaultIPv6RouteEnabled)
{
    LogRelFlow(("{%p} %s: enter aAdvertiseDefaultIPv6RouteEnabled=%p\n", this, "NATNetwork::getAdvertiseDefaultIPv6RouteEnabled", aAdvertiseDefaultIPv6RouteEnabled));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMSETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL aAdvertiseDefaultIPv6RouteEnabled)
{
    LogRelFlow(("{%p} %s: enter aAdvertiseDefaultIPv6RouteEnabled=%RTbool\n", this, "NATNetwork::setAdvertiseDefaultIPv6RouteEnabled", aAdvertiseDefaultIPv6RouteEnabled));

    // Clear 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_NATNETWORK_SET_ADVERTISEDEFAULTIPV6ROUTE_ENTER(this, aAdvertiseDefaultIPv6RouteEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAdvertiseDefaultIPv6RouteEnabled(aAdvertiseDefaultIPv6RouteEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_ADVERTISEDEFAULTIPV6ROUTE_RETURN(this, hrc, 0 /*normal*/,aAdvertiseDefaultIPv6RouteEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_ADVERTISEDEFAULTIPV6ROUTE_RETURN(this, hrc, 1 /*hrc exception*/,aAdvertiseDefaultIPv6RouteEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_ADVERTISEDEFAULTIPV6ROUTE_RETURN(this, hrc, 9 /*unhandled exception*/,aAdvertiseDefaultIPv6RouteEnabled != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(NeedDhcpServer)(BOOL *aNeedDhcpServer)
{
    LogRelFlow(("{%p} %s: enter aNeedDhcpServer=%p\n", this, "NATNetwork::getNeedDhcpServer", aNeedDhcpServer));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMSETTER(NeedDhcpServer)(BOOL aNeedDhcpServer)
{
    LogRelFlow(("{%p} %s: enter aNeedDhcpServer=%RTbool\n", this, "NATNetwork::setNeedDhcpServer", aNeedDhcpServer));

    // Clear 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_NATNETWORK_SET_NEEDDHCPSERVER_ENTER(this, aNeedDhcpServer != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNeedDhcpServer(aNeedDhcpServer != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NEEDDHCPSERVER_RETURN(this, hrc, 0 /*normal*/,aNeedDhcpServer != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NEEDDHCPSERVER_RETURN(this, hrc, 1 /*hrc exception*/,aNeedDhcpServer != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NEEDDHCPSERVER_RETURN(this, hrc, 9 /*unhandled exception*/,aNeedDhcpServer != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(PortForwardRules4)(ComSafeArrayOut(BSTR, aPortForwardRules4))
{
    LogRelFlow(("{%p} %s: enter aPortForwardRules4=%p\n", this, "NATNetwork::getPortForwardRules4", aPortForwardRules4));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMGETTER(LocalMappings)(ComSafeArrayOut(BSTR, aLocalMappings))
{
    LogRelFlow(("{%p} %s: enter aLocalMappings=%p\n", this, "NATNetwork::getLocalMappings", aLocalMappings));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMGETTER(LocalhostReachable)(BOOL *aLocalhostReachable)
{
    LogRelFlow(("{%p} %s: enter aLocalhostReachable=%p\n", this, "NATNetwork::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_NATNETWORK_GET_LOCALHOSTREACHABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLocalhostReachable(aLocalhostReachable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_LOCALHOSTREACHABLE_RETURN(this, hrc, 0 /*normal*/,*aLocalhostReachable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_LOCALHOSTREACHABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aLocalhostReachable != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(LocalhostReachable)(BOOL aLocalhostReachable)
{
    LogRelFlow(("{%p} %s: enter aLocalhostReachable=%RTbool\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_LOCALHOSTREACHABLE_RETURN(this, hrc, 0 /*normal*/,aLocalhostReachable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_LOCALHOSTREACHABLE_RETURN(this, hrc, 9 /*unhandled exception*/,aLocalhostReachable != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(ForwardBroadcast)(BOOL *aForwardBroadcast)
{
    LogRelFlow(("{%p} %s: enter aForwardBroadcast=%p\n", this, "NATNetwork::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_NATNETWORK_GET_FORWARDBROADCAST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getForwardBroadcast(aForwardBroadcast);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_FORWARDBROADCAST_RETURN(this, hrc, 0 /*normal*/,*aForwardBroadcast != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_FORWARDBROADCAST_RETURN(this, hrc, 9 /*unhandled exception*/,*aForwardBroadcast != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(ForwardBroadcast)(BOOL aForwardBroadcast)
{
    LogRelFlow(("{%p} %s: enter aForwardBroadcast=%RTbool\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_FORWARDBROADCAST_RETURN(this, hrc, 0 /*normal*/,aForwardBroadcast != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_FORWARDBROADCAST_RETURN(this, hrc, 9 /*unhandled exception*/,aForwardBroadcast != FALSE);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(NatMTU)(ULONG *aNatMTU)
{
    LogRelFlow(("{%p} %s: enter aNatMTU=%p\n", this, "NATNetwork::getNatMTU", aNatMTU));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMSETTER(NatMTU)(ULONG aNatMTU)
{
    LogRelFlow(("{%p} %s: enter aNatMTU=%RU32\n", this, "NATNetwork::setNatMTU", aNatMTU));

    // Clear 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_NATNETWORK_SET_NATMTU_ENTER(this, aNatMTU);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNatMTU(aNatMTU);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NATMTU_RETURN(this, hrc, 0 /*normal*/,aNatMTU);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NATMTU_RETURN(this, hrc, 1 /*hrc exception*/,aNatMTU);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_NATMTU_RETURN(this, hrc, 9 /*unhandled exception*/,aNatMTU);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(NatMRU)(ULONG *aNatMRU)
{
    LogRelFlow(("{%p} %s: enter aNatMRU=%p\n", this, "NATNetwork::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_NATNETWORK_GET_NATMRU_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNatMRU(aNatMRU);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_GET_NATMRU_RETURN(this, hrc, 0 /*normal*/,*aNatMRU);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_GET_NATMRU_RETURN(this, hrc, 9 /*unhandled exception*/,*aNatMRU);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMSETTER(NatMRU)(ULONG aNatMRU)
{
    LogRelFlow(("{%p} %s: enter aNatMRU=%RU32\n", this, "NATNetwork::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_NATNETWORK_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_NATNETWORK_SET_NATMRU_RETURN(this, hrc, 0 /*normal*/,aNatMRU);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_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_NATNETWORK_SET_NATMRU_RETURN(this, hrc, 9 /*unhandled exception*/,aNatMRU);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(LoopbackIp6)(LONG *aLoopbackIp6)
{
    LogRelFlow(("{%p} %s: enter aLoopbackIp6=%p\n", this, "NATNetwork::getLoopbackIp6", aLoopbackIp6));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aLoopbackIp6=%RI32 hrc=%Rhrc\n", this, "NATNetwork::getLoopbackIp6", !RT_VALID_PTR(aLoopbackIp6) ? 0 : *aLoopbackIp6, hrc));
    return hrc;
}

STDMETHODIMP NATNetworkWrap::COMSETTER(LoopbackIp6)(LONG aLoopbackIp6)
{
    LogRelFlow(("{%p} %s: enter aLoopbackIp6=%RI32\n", this, "NATNetwork::setLoopbackIp6", aLoopbackIp6));

    // Clear 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_NATNETWORK_SET_LOOPBACKIP6_ENTER(this, aLoopbackIp6);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLoopbackIp6(aLoopbackIp6);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_LOOPBACKIP6_RETURN(this, hrc, 0 /*normal*/,aLoopbackIp6);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_LOOPBACKIP6_RETURN(this, hrc, 1 /*hrc exception*/,aLoopbackIp6);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_SET_LOOPBACKIP6_RETURN(this, hrc, 9 /*unhandled exception*/,aLoopbackIp6);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::COMGETTER(PortForwardRules6)(ComSafeArrayOut(BSTR, aPortForwardRules6))
{
    LogRelFlow(("{%p} %s: enter aPortForwardRules6=%p\n", this, "NATNetwork::getPortForwardRules6", aPortForwardRules6));

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

    HRESULT hrc;

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

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

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute1INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute2INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute3INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute4INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute5INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute6INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute7INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::COMGETTER(InternalAndReservedAttribute8INATNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// INATNetwork methods
//

STDMETHODIMP NATNetworkWrap::AddLocalMapping(IN_BSTR aHostid,
                                             LONG aOffset)
{
    LogRelFlow(("{%p} %s: enter aHostid=%ls aOffset=%RI32\n", this, "NATNetwork::addLocalMapping", aHostid, 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
    {


        BSTRInConverter TmpHostid(aHostid);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDLOCALMAPPING_ENTER(this, TmpHostid.str().c_str(), aOffset);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addLocalMapping(TmpHostid.str(),
                                  aOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDLOCALMAPPING_RETURN(this, hrc, 0 /*normal*/, TmpHostid.str().c_str(), aOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDLOCALMAPPING_RETURN(this, hrc, 1 /*hrc exception*/, 0, aOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDLOCALMAPPING_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aOffset);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::AddPortForwardRule(BOOL aIsIpv6,
                                                IN_BSTR aRuleName,
                                                NATProtocol_T aProto,
                                                IN_BSTR aHostIP,
                                                USHORT aHostPort,
                                                IN_BSTR aGuestIP,
                                                USHORT aGuestPort)
{
    LogRelFlow(("{%p} %s: enter aIsIpv6=%RTbool aRuleName=%ls aProto=%RU32 aHostIP=%ls aHostPort=%RU16 aGuestIP=%ls aGuestPort=%RU16\n", this, "NATNetwork::addPortForwardRule", aIsIpv6, aRuleName, 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 TmpRuleName(aRuleName);
        
        BSTRInConverter TmpHostIP(aHostIP);
        
        BSTRInConverter TmpGuestIP(aGuestIP);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDPORTFORWARDRULE_ENTER(this, aIsIpv6 != FALSE, TmpRuleName.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 = addPortForwardRule(aIsIpv6 != FALSE,
                                     TmpRuleName.str(),
                                     aProto,
                                     TmpHostIP.str(),
                                     aHostPort,
                                     TmpGuestIP.str(),
                                     aGuestPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDPORTFORWARDRULE_RETURN(this, hrc, 0 /*normal*/, aIsIpv6 != FALSE, TmpRuleName.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_NATNETWORK_ADDPORTFORWARDRULE_RETURN(this, hrc, 1 /*hrc exception*/, aIsIpv6 != FALSE, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_ADDPORTFORWARDRULE_RETURN(this, hrc, 9 /*unhandled exception*/, aIsIpv6 != FALSE, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::RemovePortForwardRule(BOOL aIsIpv6,
                                                   IN_BSTR aRuleName)
{
    LogRelFlow(("{%p} %s: enter aIsIpv6=%RTbool aRuleName=%ls\n", this, "NATNetwork::removePortForwardRule", aIsIpv6, aRuleName));

    // Clear 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 TmpRuleName(aRuleName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_REMOVEPORTFORWARDRULE_ENTER(this, aIsIpv6 != FALSE, TmpRuleName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removePortForwardRule(aIsIpv6 != FALSE,
                                        TmpRuleName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_REMOVEPORTFORWARDRULE_RETURN(this, hrc, 0 /*normal*/, aIsIpv6 != FALSE, TmpRuleName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_REMOVEPORTFORWARDRULE_RETURN(this, hrc, 1 /*hrc exception*/, aIsIpv6 != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_REMOVEPORTFORWARDRULE_RETURN(this, hrc, 9 /*unhandled exception*/, aIsIpv6 != FALSE, 0);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::Start()
{
    LogRelFlow(("{%p} %s: enter\n", this, "NATNetwork::start"));

    // Clear 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_NATNETWORK_START_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = start();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_START_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_START_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_START_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::Stop()
{
    LogRelFlow(("{%p} %s: enter\n", this, "NATNetwork::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_NATNETWORK_STOP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = stop();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_STOP_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_STOP_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATNETWORK_STOP_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP NATNetworkWrap::InternalAndReservedMethod1INATNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::InternalAndReservedMethod2INATNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::InternalAndReservedMethod3INATNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATNetworkWrap::InternalAndReservedMethod4INATNetwork()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(NATNetworkWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NATNetworkWrap, INATNetwork)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "NATNetworkWrap.cpp"


// ##### BEGINFILE "HostOnlyNetworkWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostOnlyNetwork.
 *
 * 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_HOSTONLYNETWORK

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

DEFINE_EMPTY_CTOR_DTOR(HostOnlyNetworkWrap)

//
// IHostOnlyNetwork properties
//

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(NetworkName)(IN_BSTR aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%ls\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_SET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(NetworkMask)(BSTR *aNetworkMask)
{
    LogRelFlow(("{%p} %s: enter aNetworkMask=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_NETWORKMASK_RETURN(this, hrc, 0 /*normal*/,TmpNetworkMask.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_NETWORKMASK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(NetworkMask)(IN_BSTR aNetworkMask)
{
    LogRelFlow(("{%p} %s: enter aNetworkMask=%ls\n", this, "HostOnlyNetwork::setNetworkMask", 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
    {
        BSTRInConverter TmpNetworkMask(aNetworkMask);

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

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(HostIP)(BSTR *aHostIP)
{
    LogRelFlow(("{%p} %s: enter aHostIP=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_HOSTIP_RETURN(this, hrc, 0 /*normal*/,TmpHostIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_HOSTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(LowerIP)(BSTR *aLowerIP)
{
    LogRelFlow(("{%p} %s: enter aLowerIP=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_LOWERIP_RETURN(this, hrc, 0 /*normal*/,TmpLowerIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_LOWERIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(LowerIP)(IN_BSTR aLowerIP)
{
    LogRelFlow(("{%p} %s: enter aLowerIP=%ls\n", this, "HostOnlyNetwork::setLowerIP", 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
    {
        BSTRInConverter TmpLowerIP(aLowerIP);

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

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(UpperIP)(BSTR *aUpperIP)
{
    LogRelFlow(("{%p} %s: enter aUpperIP=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_UPPERIP_RETURN(this, hrc, 0 /*normal*/,TmpUpperIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_UPPERIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(UpperIP)(IN_BSTR aUpperIP)
{
    LogRelFlow(("{%p} %s: enter aUpperIP=%ls\n", this, "HostOnlyNetwork::setUpperIP", 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
    {
        BSTRInConverter TmpUpperIP(aUpperIP);

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

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "HostOnlyNetwork::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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_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_HOSTONLYNETWORK_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostOnlyNetworkWrap::COMSETTER(Id)(IN_BSTR aId)
{
    LogRelFlow(("{%p} %s: enter aId=%ls\n", this, "HostOnlyNetwork::setId", 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
    {
        UuidInConverter TmpId(aId);

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

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

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute1IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute2IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute3IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute4IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute5IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute6IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute7IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::COMGETTER(InternalAndReservedAttribute8IHostOnlyNetwork)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostOnlyNetwork methods
//

STDMETHODIMP HostOnlyNetworkWrap::InternalAndReservedMethod1IHostOnlyNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::InternalAndReservedMethod2IHostOnlyNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::InternalAndReservedMethod3IHostOnlyNetwork()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostOnlyNetworkWrap::InternalAndReservedMethod4IHostOnlyNetwork()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostOnlyNetworkWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostOnlyNetworkWrap, IHostOnlyNetwork)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostOnlyNetworkWrap.cpp"


// ##### BEGINFILE "DHCPConfigWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPConfig.
 *
 * 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_DHCPCONFIG

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

DEFINE_EMPTY_CTOR_DTOR(DHCPConfigWrap)

//
// IDHCPConfig properties
//

STDMETHODIMP DHCPConfigWrap::COMGETTER(Scope)(DHCPConfigScope_T *aScope)
{
    LogRelFlow(("{%p} %s: enter aScope=%p\n", this, "DHCPConfig::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_DHCPCONFIG_GET_SCOPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScope(aScope);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_GET_SCOPE_RETURN(this, hrc, 0 /*normal*/,*aScope);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_GET_SCOPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aScope);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMGETTER(MinLeaseTime)(ULONG *aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%p\n", this, "DHCPConfig::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_DHCPCONFIG_GET_MINLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMSETTER(MinLeaseTime)(ULONG aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%RU32\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMinLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMGETTER(DefaultLeaseTime)(ULONG *aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%p\n", this, "DHCPConfig::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_DHCPCONFIG_GET_DEFAULTLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMSETTER(DefaultLeaseTime)(ULONG aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%RU32\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMGETTER(MaxLeaseTime)(ULONG *aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%p\n", this, "DHCPConfig::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_DHCPCONFIG_GET_MAXLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMSETTER(MaxLeaseTime)(ULONG aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%RU32\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_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_DHCPCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMGETTER(ForcedOptions)(ComSafeArrayOut(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%p\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMSETTER(ForcedOptions)(ComSafeArrayIn(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%zu\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMGETTER(SuppressedOptions)(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%p\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::COMSETTER(SuppressedOptions)(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%zu\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


//
// IDHCPConfig methods
//

STDMETHODIMP DHCPConfigWrap::SetOption(DHCPOption_T aOption,
                                       DHCPOptionEncoding_T aEncoding,
                                       IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%RU32 aValue=%ls\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_SETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, aEncoding, 0);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::RemoveOption(DHCPOption_T aOption)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32\n", this, "DHCPConfig::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_DHCPCONFIG_REMOVEOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeOption(aOption);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEOPTION_RETURN(this, hrc, 0 /*normal*/, aOption);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::RemoveAllOptions()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPConfig::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_DHCPCONFIG_REMOVEALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllOptions();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::GetOption(DHCPOption_T aOption,
                                       DHCPOptionEncoding_T *aEncoding,
                                       BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%p aValue=%p\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_GETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, *aEncoding, 0);
#endif
    }

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

STDMETHODIMP DHCPConfigWrap::GetAllOptions(ComSafeArrayOut(DHCPOption_T, aOptions),
                                           ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                                           ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aOptions=%p aEncodings=%p aValues=%p\n", this, "DHCPConfig::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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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_DHCPCONFIG_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, "DHCPConfig::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 DHCPConfigWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPConfig::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_DHCPCONFIG_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPCONFIG_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

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

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

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

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

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

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

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

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

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPConfigWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DHCPConfigWrap, IDHCPConfig)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPConfigWrap.cpp"


// ##### BEGINFILE "DHCPGroupConditionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPGroupCondition.
 *
 * 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_DHCPGROUPCONDITION

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

DEFINE_EMPTY_CTOR_DTOR(DHCPGroupConditionWrap)

//
// IDHCPGroupCondition properties
//

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(Inclusive)(BOOL *aInclusive)
{
    LogRelFlow(("{%p} %s: enter aInclusive=%p\n", this, "DHCPGroupCondition::getInclusive", aInclusive));

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

    HRESULT hrc;

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

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

STDMETHODIMP DHCPGroupConditionWrap::COMSETTER(Inclusive)(BOOL aInclusive)
{
    LogRelFlow(("{%p} %s: enter aInclusive=%RTbool\n", this, "DHCPGroupCondition::setInclusive", aInclusive));

    // Clear 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_DHCPGROUPCONDITION_SET_INCLUSIVE_ENTER(this, aInclusive != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInclusive(aInclusive != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_INCLUSIVE_RETURN(this, hrc, 0 /*normal*/,aInclusive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_INCLUSIVE_RETURN(this, hrc, 1 /*hrc exception*/,aInclusive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_INCLUSIVE_RETURN(this, hrc, 9 /*unhandled exception*/,aInclusive != FALSE);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(Type)(DHCPGroupConditionType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "DHCPGroupCondition::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_DHCPGROUPCONDITION_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_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_DHCPGROUPCONDITION_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::COMSETTER(Type)(DHCPGroupConditionType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "DHCPGroupCondition::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_DHCPGROUPCONDITION_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_DHCPGROUPCONDITION_SET_TYPE_RETURN(this, hrc, 0 /*normal*/,aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_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_DHCPGROUPCONDITION_SET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aType);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(Value)(BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aValue=%p\n", this, "DHCPGroupCondition::getValue", 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);
        BSTROutConverter TmpValue(aValue);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_GET_VALUE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValue(TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_GET_VALUE_RETURN(this, hrc, 0 /*normal*/,TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_GET_VALUE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_GET_VALUE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::COMSETTER(Value)(IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aValue=%ls\n", this, "DHCPGroupCondition::setValue", 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_DHCPGROUPCONDITION_SET_VALUE_ENTER(this, TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setValue(TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_VALUE_RETURN(this, hrc, 0 /*normal*/,TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_VALUE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_SET_VALUE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(InternalAndReservedAttribute1IDHCPGroupCondition)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(InternalAndReservedAttribute2IDHCPGroupCondition)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConditionWrap::COMGETTER(InternalAndReservedAttribute3IDHCPGroupCondition)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDHCPGroupCondition methods
//

STDMETHODIMP DHCPGroupConditionWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPGroupCondition::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_DHCPGROUPCONDITION_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPGROUPCONDITION_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP DHCPGroupConditionWrap::InternalAndReservedMethod1IDHCPGroupCondition()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConditionWrap::InternalAndReservedMethod2IDHCPGroupCondition()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPGroupConditionWrap::InternalAndReservedMethod3IDHCPGroupCondition()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPGroupConditionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DHCPGroupConditionWrap, IDHCPGroupCondition)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPGroupConditionWrap.cpp"


// ##### BEGINFILE "DHCPIndividualConfigWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDHCPIndividualConfig.
 *
 * 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_DHCPINDIVIDUALCONFIG

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

DEFINE_EMPTY_CTOR_DTOR(DHCPIndividualConfigWrap)

//
// IDHCPConfig properties
//

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(Scope)(DHCPConfigScope_T *aScope)
{
    LogRelFlow(("{%p} %s: enter aScope=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_GET_SCOPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScope(aScope);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_SCOPE_RETURN(this, hrc, 0 /*normal*/,*aScope);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_SCOPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aScope);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(MinLeaseTime)(ULONG *aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_GET_MINLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinLeaseTime(aMinLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(MinLeaseTime)(ULONG aMinLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMinLeaseTime=%RU32\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMinLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_MINLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMinLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(DefaultLeaseTime)(ULONG *aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_GET_DEFAULTLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultLeaseTime(aDefaultLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(DefaultLeaseTime)(ULONG aDefaultLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aDefaultLeaseTime=%RU32\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 0 /*normal*/,aDefaultLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_DEFAULTLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(MaxLeaseTime)(ULONG *aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_GET_MAXLEASETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxLeaseTime(aMaxLeaseTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,*aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(MaxLeaseTime)(ULONG aMaxLeaseTime)
{
    LogRelFlow(("{%p} %s: enter aMaxLeaseTime=%RU32\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 0 /*normal*/,aMaxLeaseTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_MAXLEASETIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxLeaseTime);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(ForcedOptions)(ComSafeArrayOut(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(ForcedOptions)(ComSafeArrayIn(DHCPOption_T, aForcedOptions))
{
    LogRelFlow(("{%p} %s: enter aForcedOptions=%zu\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_FORCEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(SuppressedOptions)(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(SuppressedOptions)(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions))
{
    LogRelFlow(("{%p} %s: enter aSuppressedOptions=%zu\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SET_SUPPRESSEDOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//
// IDHCPIndividualConfig properties
//

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(MACAddress)(BSTR *aMACAddress)
{
    LogRelFlow(("{%p} %s: enter aMACAddress=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_MACADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpMACAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_MACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(MachineId)(BSTR *aMachineId)
{
    LogRelFlow(("{%p} %s: enter aMachineId=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_MACHINEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(Slot)(ULONG *aSlot)
{
    LogRelFlow(("{%p} %s: enter aSlot=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_GET_SLOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSlot(aSlot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_SLOT_RETURN(this, hrc, 0 /*normal*/,*aSlot);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GET_SLOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSlot);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(FixedAddress)(BSTR *aFixedAddress)
{
    LogRelFlow(("{%p} %s: enter aFixedAddress=%p\n", this, "DHCPIndividualConfig::getFixedAddress", aFixedAddress));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFixedAddress);
        BSTROutConverter TmpFixedAddress(aFixedAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_FIXEDADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFixedAddress(TmpFixedAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_FIXEDADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpFixedAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_FIXEDADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_GET_FIXEDADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::COMSETTER(FixedAddress)(IN_BSTR aFixedAddress)
{
    LogRelFlow(("{%p} %s: enter aFixedAddress=%ls\n", this, "DHCPIndividualConfig::setFixedAddress", aFixedAddress));

    // Clear 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 TmpFixedAddress(aFixedAddress);

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

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

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute1IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute2IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute3IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute4IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute5IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute6IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute7IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::COMGETTER(InternalAndReservedAttribute8IDHCPIndividualConfig)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDHCPConfig methods
//

STDMETHODIMP DHCPIndividualConfigWrap::SetOption(DHCPOption_T aOption,
                                                 DHCPOptionEncoding_T aEncoding,
                                                 IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%RU32 aValue=%ls\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_SETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, aEncoding, 0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::RemoveOption(DHCPOption_T aOption)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_REMOVEOPTION_ENTER(this, aOption);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeOption(aOption);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEOPTION_RETURN(this, hrc, 0 /*normal*/, aOption);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEOPTION_RETURN(this, hrc, 1 /*hrc exception*/, aOption);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::RemoveAllOptions()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_REMOVEALLOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllOptions();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVEALLOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::GetOption(DHCPOption_T aOption,
                                                 DHCPOptionEncoding_T *aEncoding,
                                                 BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aOption=%RU32 aEncoding=%p aValue=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_GETOPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aOption, *aEncoding, 0);
#endif
    }

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

STDMETHODIMP DHCPIndividualConfigWrap::GetAllOptions(ComSafeArrayOut(DHCPOption_T, aOptions),
                                                     ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                                                     ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aOptions=%p aEncodings=%p aValues=%p\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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_DHCPINDIVIDUALCONFIG_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, "DHCPIndividualConfig::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 DHCPIndividualConfigWrap::Remove()
{
    LogRelFlow(("{%p} %s: enter\n", this, "DHCPIndividualConfig::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_DHCPINDIVIDUALCONFIG_REMOVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = remove();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DHCPINDIVIDUALCONFIG_REMOVE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

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

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

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

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

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

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

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

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

//
// IDHCPIndividualConfig methods
//

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod1IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod2IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod3IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod4IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod5IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod6IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod7IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

STDMETHODIMP DHCPIndividualConfigWrap::InternalAndReservedMethod8IDHCPIndividualConfig()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DHCPIndividualConfigWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DHCPIndividualConfigWrap, IDHCPIndividualConfig, IDHCPConfig)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DHCPIndividualConfigWrap.cpp"


// ##### BEGINFILE "ApplianceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IAppliance.
 *
 * 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_APPLIANCE

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

DEFINE_EMPTY_CTOR_DTOR(ApplianceWrap)

//
// IAppliance properties
//

STDMETHODIMP ApplianceWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "Appliance::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_APPLIANCE_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_APPLIANCE_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_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_APPLIANCE_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::COMGETTER(Disks)(ComSafeArrayOut(BSTR, aDisks))
{
    LogRelFlow(("{%p} %s: enter aDisks=%p\n", this, "Appliance::getDisks", aDisks));

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

    HRESULT hrc;

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

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

STDMETHODIMP ApplianceWrap::COMGETTER(VirtualSystemDescriptions)(ComSafeArrayOut(IVirtualSystemDescription *, aVirtualSystemDescriptions))
{
    LogRelFlow(("{%p} %s: enter aVirtualSystemDescriptions=%p\n", this, "Appliance::getVirtualSystemDescriptions", aVirtualSystemDescriptions));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVirtualSystemDescriptions);
        ArrayComTypeOutConverter<IVirtualSystemDescription> TmpVirtualSystemDescriptions(ComSafeArrayOutArg(aVirtualSystemDescriptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_VIRTUALSYSTEMDESCRIPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVirtualSystemDescriptions(TmpVirtualSystemDescriptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_VIRTUALSYSTEMDESCRIPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpVirtualSystemDescriptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_VIRTUALSYSTEMDESCRIPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_VIRTUALSYSTEMDESCRIPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::COMGETTER(Machines)(ComSafeArrayOut(BSTR, aMachines))
{
    LogRelFlow(("{%p} %s: enter aMachines=%p\n", this, "Appliance::getMachines", aMachines));

    // Clear error 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);
        ArrayBSTROutConverter TmpMachines(ComSafeArrayOutArg(aMachines));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_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_APPLIANCE_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_APPLIANCE_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_APPLIANCE_GET_MACHINES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::COMGETTER(Certificate)(ICertificate **aCertificate)
{
    LogRelFlow(("{%p} %s: enter aCertificate=%p\n", this, "Appliance::getCertificate", aCertificate));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCertificate);
        ComTypeOutConverter<ICertificate> TmpCertificate(aCertificate);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_CERTIFICATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCertificate(TmpCertificate.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_CERTIFICATE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpCertificate.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_CERTIFICATE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GET_CERTIFICATE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute1IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute2IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute3IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute4IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute5IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute6IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute7IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::COMGETTER(InternalAndReservedAttribute8IAppliance)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IAppliance methods
//

STDMETHODIMP ApplianceWrap::Read(IN_BSTR aFile,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFile=%ls aProgress=%p\n", this, "Appliance::read", aFile, 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 TmpFile(aFile);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

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

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

STDMETHODIMP ApplianceWrap::Interpret()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Appliance::interpret"));

    // Clear 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_APPLIANCE_INTERPRET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = interpret();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_INTERPRET_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_INTERPRET_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_INTERPRET_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ApplianceWrap::ImportMachines(ComSafeArrayIn(ImportOptions_T, aOptions),
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aOptions=%zu aProgress=%p\n", this, "Appliance::importMachines", 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);


        ArrayInConverter<ImportOptions_T> TmpOptions(ComSafeArrayInArg(aOptions));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_IMPORTMACHINES_ENTER(this, (uint32_t)TmpOptions.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = importMachines(TmpOptions.array(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_IMPORTMACHINES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpOptions.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_IMPORTMACHINES_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_APPLIANCE_IMPORTMACHINES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::CreateVFSExplorer(IN_BSTR aURI,
                                              IVFSExplorer **aExplorer)
{
    LogRelFlow(("{%p} %s: enter aURI=%ls aExplorer=%p\n", this, "Appliance::createVFSExplorer", aURI, 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);


        BSTRInConverter TmpURI(aURI);
        ComTypeOutConverter<IVFSExplorer> TmpExplorer(aExplorer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_CREATEVFSEXPLORER_ENTER(this, TmpURI.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createVFSExplorer(TmpURI.str(),
                                    TmpExplorer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_CREATEVFSEXPLORER_RETURN(this, hrc, 0 /*normal*/, TmpURI.str().c_str(), (void *)TmpExplorer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_CREATEVFSEXPLORER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_CREATEVFSEXPLORER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::Write(IN_BSTR aFormat,
                                  ComSafeArrayIn(ExportOptions_T, aOptions),
                                  IN_BSTR aPath,
                                  IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aOptions=%zu aPath=%ls aProgress=%p\n", this, "Appliance::write", aFormat, aOptions, 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);


        BSTRInConverter TmpFormat(aFormat);
        ArrayInConverter<ExportOptions_T> TmpOptions(ComSafeArrayInArg(aOptions));
        BSTRInConverter TmpPath(aPath);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_WRITE_ENTER(this, TmpFormat.str().c_str(), (uint32_t)TmpOptions.array().size(), NULL /*for now*/, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(TmpFormat.str(),
                        TmpOptions.array(),
                        TmpPath.str(),
                        TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_WRITE_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), (uint32_t)TmpOptions.array().size(), NULL /*for now*/, TmpPath.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_WRITE_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_APPLIANCE_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::GetWarnings(ComSafeArrayOut(BSTR, aWarnings))
{
    LogRelFlow(("{%p} %s: enter aWarnings=%p\n", this, "Appliance::getWarnings", aWarnings));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWarnings);


        ArrayBSTROutConverter TmpWarnings(ComSafeArrayOutArg(aWarnings));

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

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

STDMETHODIMP ApplianceWrap::GetPasswordIds(ComSafeArrayOut(BSTR, aIdentifiers))
{
    LogRelFlow(("{%p} %s: enter aIdentifiers=%p\n", this, "Appliance::getPasswordIds", aIdentifiers));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIdentifiers);


        ArrayBSTROutConverter TmpIdentifiers(ComSafeArrayOutArg(aIdentifiers));

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

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

STDMETHODIMP ApplianceWrap::GetMediumIdsForPasswordId(IN_BSTR aPasswordId,
                                                      ComSafeArrayOut(BSTR, aIdentifiers))
{
    LogRelFlow(("{%p} %s: enter aPasswordId=%ls aIdentifiers=%p\n", this, "Appliance::getMediumIdsForPasswordId", aPasswordId, aIdentifiers));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIdentifiers);


        BSTRInConverter TmpPasswordId(aPasswordId);
        ArrayUuidOutConverter TmpIdentifiers(ComSafeArrayOutArg(aIdentifiers));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GETMEDIUMIDSFORPASSWORDID_ENTER(this, TmpPasswordId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumIdsForPasswordId(TmpPasswordId.str(),
                                            TmpIdentifiers.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GETMEDIUMIDSFORPASSWORDID_RETURN(this, hrc, 0 /*normal*/, TmpPasswordId.str().c_str(), (uint32_t)TmpIdentifiers.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_GETMEDIUMIDSFORPASSWORDID_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_APPLIANCE_GETMEDIUMIDSFORPASSWORDID_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::AddPasswords(ComSafeArrayIn(IN_BSTR, aIdentifiers),
                                         ComSafeArrayIn(IN_BSTR, aPasswords))
{
    LogRelFlow(("{%p} %s: enter aIdentifiers=%zu aPasswords=%zu\n", this, "Appliance::addPasswords", aIdentifiers, 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 TmpIdentifiers(ComSafeArrayInArg(aIdentifiers));
        ArrayBSTRInConverter TmpPasswords(ComSafeArrayInArg(aPasswords));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_ADDPASSWORDS_ENTER(this, (uint32_t)TmpIdentifiers.array().size(), NULL /*for now*/, (uint32_t)TmpPasswords.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addPasswords(TmpIdentifiers.array(),
                               TmpPasswords.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_APPLIANCE_ADDPASSWORDS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpIdentifiers.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_APPLIANCE_ADDPASSWORDS_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_APPLIANCE_ADDPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP ApplianceWrap::CreateVirtualSystemDescriptions(ULONG aRequested,
                                                            ULONG *aCreated)
{
    LogRelFlow(("{%p} %s: enter aRequested=%RU32 aCreated=%p\n", this, "Appliance::createVirtualSystemDescriptions", aRequested, aCreated));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCreated);


        
        

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

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

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod1IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod2IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod3IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod4IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod5IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod6IAppliance()
{
    return E_NOTIMPL;
}

STDMETHODIMP ApplianceWrap::InternalAndReservedMethod7IAppliance()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ApplianceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ApplianceWrap, IAppliance)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ApplianceWrap.cpp"


// ##### BEGINFILE "UnattendedWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUnattended.
 *
 * 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_UNATTENDED

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

DEFINE_EMPTY_CTOR_DTOR(UnattendedWrap)

//
// IUnattended properties
//

STDMETHODIMP UnattendedWrap::COMGETTER(IsoPath)(BSTR *aIsoPath)
{
    LogRelFlow(("{%p} %s: enter aIsoPath=%p\n", this, "Unattended::getIsoPath", aIsoPath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsoPath);
        BSTROutConverter TmpIsoPath(aIsoPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ISOPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsoPath(TmpIsoPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ISOPATH_RETURN(this, hrc, 0 /*normal*/,TmpIsoPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ISOPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ISOPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(IsoPath)(IN_BSTR aIsoPath)
{
    LogRelFlow(("{%p} %s: enter aIsoPath=%ls\n", this, "Unattended::setIsoPath", aIsoPath));

    // Clear 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 TmpIsoPath(aIsoPath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Unattended::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_UNATTENDED_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_UNATTENDED_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_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_UNATTENDED_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Machine)(IMachine *aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Unattended::setMachine", 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_UNATTENDED_SET_MACHINE_ENTER(this, (void *)TmpMachine.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(User)(BSTR *aUser)
{
    LogRelFlow(("{%p} %s: enter aUser=%p\n", this, "Unattended::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_UNATTENDED_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_UNATTENDED_GET_USER_RETURN(this, hrc, 0 /*normal*/,TmpUser.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_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_UNATTENDED_GET_USER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(User)(IN_BSTR aUser)
{
    LogRelFlow(("{%p} %s: enter aUser=%ls\n", this, "Unattended::setUser", 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
    {
        BSTRInConverter TmpUser(aUser);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(UserPassword)(BSTR *aUserPassword)
{
    LogRelFlow(("{%p} %s: enter aUserPassword=%p\n", this, "Unattended::getUserPassword", aUserPassword));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserPassword);
        BSTROutConverter TmpUserPassword(aUserPassword);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPASSWORD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserPassword(TmpUserPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPASSWORD_RETURN(this, hrc, 0 /*normal*/,TmpUserPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(UserPassword)(IN_BSTR aUserPassword)
{
    LogRelFlow(("{%p} %s: enter aUserPassword=%ls\n", this, "Unattended::setUserPassword", aUserPassword));

    // Clear 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 TmpUserPassword(aUserPassword);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(AdminPassword)(BSTR *aAdminPassword)
{
    LogRelFlow(("{%p} %s: enter aAdminPassword=%p\n", this, "Unattended::getAdminPassword", aAdminPassword));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdminPassword);
        BSTROutConverter TmpAdminPassword(aAdminPassword);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADMINPASSWORD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdminPassword(TmpAdminPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADMINPASSWORD_RETURN(this, hrc, 0 /*normal*/,TmpAdminPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADMINPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADMINPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(AdminPassword)(IN_BSTR aAdminPassword)
{
    LogRelFlow(("{%p} %s: enter aAdminPassword=%ls\n", this, "Unattended::setAdminPassword", aAdminPassword));

    // Clear 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 TmpAdminPassword(aAdminPassword);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(FullUserName)(BSTR *aFullUserName)
{
    LogRelFlow(("{%p} %s: enter aFullUserName=%p\n", this, "Unattended::getFullUserName", aFullUserName));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFullUserName);
        BSTROutConverter TmpFullUserName(aFullUserName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_FULLUSERNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFullUserName(TmpFullUserName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_FULLUSERNAME_RETURN(this, hrc, 0 /*normal*/,TmpFullUserName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_FULLUSERNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_FULLUSERNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(FullUserName)(IN_BSTR aFullUserName)
{
    LogRelFlow(("{%p} %s: enter aFullUserName=%ls\n", this, "Unattended::setFullUserName", aFullUserName));

    // Clear 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 TmpFullUserName(aFullUserName);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(ProductKey)(BSTR *aProductKey)
{
    LogRelFlow(("{%p} %s: enter aProductKey=%p\n", this, "Unattended::getProductKey", aProductKey));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProductKey);
        BSTROutConverter TmpProductKey(aProductKey);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PRODUCTKEY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProductKey(TmpProductKey.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PRODUCTKEY_RETURN(this, hrc, 0 /*normal*/,TmpProductKey.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PRODUCTKEY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PRODUCTKEY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(ProductKey)(IN_BSTR aProductKey)
{
    LogRelFlow(("{%p} %s: enter aProductKey=%ls\n", this, "Unattended::setProductKey", aProductKey));

    // Clear 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 TmpProductKey(aProductKey);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(AdditionsIsoPath)(BSTR *aAdditionsIsoPath)
{
    LogRelFlow(("{%p} %s: enter aAdditionsIsoPath=%p\n", this, "Unattended::getAdditionsIsoPath", aAdditionsIsoPath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdditionsIsoPath);
        BSTROutConverter TmpAdditionsIsoPath(aAdditionsIsoPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADDITIONSISOPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdditionsIsoPath(TmpAdditionsIsoPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADDITIONSISOPATH_RETURN(this, hrc, 0 /*normal*/,TmpAdditionsIsoPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADDITIONSISOPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_ADDITIONSISOPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(AdditionsIsoPath)(IN_BSTR aAdditionsIsoPath)
{
    LogRelFlow(("{%p} %s: enter aAdditionsIsoPath=%ls\n", this, "Unattended::setAdditionsIsoPath", aAdditionsIsoPath));

    // Clear 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 TmpAdditionsIsoPath(aAdditionsIsoPath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(InstallGuestAdditions)(BOOL *aInstallGuestAdditions)
{
    LogRelFlow(("{%p} %s: enter aInstallGuestAdditions=%p\n", this, "Unattended::getInstallGuestAdditions", aInstallGuestAdditions));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMSETTER(InstallGuestAdditions)(BOOL aInstallGuestAdditions)
{
    LogRelFlow(("{%p} %s: enter aInstallGuestAdditions=%RTbool\n", this, "Unattended::setInstallGuestAdditions", aInstallGuestAdditions));

    // Clear 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_UNATTENDED_SET_INSTALLGUESTADDITIONS_ENTER(this, aInstallGuestAdditions != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInstallGuestAdditions(aInstallGuestAdditions != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLGUESTADDITIONS_RETURN(this, hrc, 0 /*normal*/,aInstallGuestAdditions != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLGUESTADDITIONS_RETURN(this, hrc, 1 /*hrc exception*/,aInstallGuestAdditions != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLGUESTADDITIONS_RETURN(this, hrc, 9 /*unhandled exception*/,aInstallGuestAdditions != FALSE);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(ProductKeyRequired)(BOOL *aProductKeyRequired)
{
    LogRelFlow(("{%p} %s: enter aProductKeyRequired=%p\n", this, "Unattended::getProductKeyRequired", aProductKeyRequired));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(ValidationKitIsoPath)(BSTR *aValidationKitIsoPath)
{
    LogRelFlow(("{%p} %s: enter aValidationKitIsoPath=%p\n", this, "Unattended::getValidationKitIsoPath", aValidationKitIsoPath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValidationKitIsoPath);
        BSTROutConverter TmpValidationKitIsoPath(aValidationKitIsoPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_VALIDATIONKITISOPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValidationKitIsoPath(TmpValidationKitIsoPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_VALIDATIONKITISOPATH_RETURN(this, hrc, 0 /*normal*/,TmpValidationKitIsoPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_VALIDATIONKITISOPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_VALIDATIONKITISOPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(ValidationKitIsoPath)(IN_BSTR aValidationKitIsoPath)
{
    LogRelFlow(("{%p} %s: enter aValidationKitIsoPath=%ls\n", this, "Unattended::setValidationKitIsoPath", aValidationKitIsoPath));

    // Clear 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 TmpValidationKitIsoPath(aValidationKitIsoPath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(InstallTestExecService)(BOOL *aInstallTestExecService)
{
    LogRelFlow(("{%p} %s: enter aInstallTestExecService=%p\n", this, "Unattended::getInstallTestExecService", aInstallTestExecService));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMSETTER(InstallTestExecService)(BOOL aInstallTestExecService)
{
    LogRelFlow(("{%p} %s: enter aInstallTestExecService=%RTbool\n", this, "Unattended::setInstallTestExecService", aInstallTestExecService));

    // Clear 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_UNATTENDED_SET_INSTALLTESTEXECSERVICE_ENTER(this, aInstallTestExecService != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInstallTestExecService(aInstallTestExecService != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLTESTEXECSERVICE_RETURN(this, hrc, 0 /*normal*/,aInstallTestExecService != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLTESTEXECSERVICE_RETURN(this, hrc, 1 /*hrc exception*/,aInstallTestExecService != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLTESTEXECSERVICE_RETURN(this, hrc, 9 /*unhandled exception*/,aInstallTestExecService != FALSE);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(UserPayloadIsoPath)(BSTR *aUserPayloadIsoPath)
{
    LogRelFlow(("{%p} %s: enter aUserPayloadIsoPath=%p\n", this, "Unattended::getUserPayloadIsoPath", aUserPayloadIsoPath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserPayloadIsoPath);
        BSTROutConverter TmpUserPayloadIsoPath(aUserPayloadIsoPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPAYLOADISOPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserPayloadIsoPath(TmpUserPayloadIsoPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPAYLOADISOPATH_RETURN(this, hrc, 0 /*normal*/,TmpUserPayloadIsoPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPAYLOADISOPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_USERPAYLOADISOPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(UserPayloadIsoPath)(IN_BSTR aUserPayloadIsoPath)
{
    LogRelFlow(("{%p} %s: enter aUserPayloadIsoPath=%ls\n", this, "Unattended::setUserPayloadIsoPath", aUserPayloadIsoPath));

    // Clear 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 TmpUserPayloadIsoPath(aUserPayloadIsoPath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(InstallUserPayload)(BOOL *aInstallUserPayload)
{
    LogRelFlow(("{%p} %s: enter aInstallUserPayload=%p\n", this, "Unattended::getInstallUserPayload", aInstallUserPayload));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMSETTER(InstallUserPayload)(BOOL aInstallUserPayload)
{
    LogRelFlow(("{%p} %s: enter aInstallUserPayload=%RTbool\n", this, "Unattended::setInstallUserPayload", aInstallUserPayload));

    // Clear 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_UNATTENDED_SET_INSTALLUSERPAYLOAD_ENTER(this, aInstallUserPayload != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInstallUserPayload(aInstallUserPayload != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLUSERPAYLOAD_RETURN(this, hrc, 0 /*normal*/,aInstallUserPayload != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLUSERPAYLOAD_RETURN(this, hrc, 1 /*hrc exception*/,aInstallUserPayload != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_INSTALLUSERPAYLOAD_RETURN(this, hrc, 9 /*unhandled exception*/,aInstallUserPayload != FALSE);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(TimeZone)(BSTR *aTimeZone)
{
    LogRelFlow(("{%p} %s: enter aTimeZone=%p\n", this, "Unattended::getTimeZone", aTimeZone));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeZone);
        BSTROutConverter TmpTimeZone(aTimeZone);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_TIMEZONE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeZone(TmpTimeZone.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_TIMEZONE_RETURN(this, hrc, 0 /*normal*/,TmpTimeZone.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_TIMEZONE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_TIMEZONE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(TimeZone)(IN_BSTR aTimeZone)
{
    LogRelFlow(("{%p} %s: enter aTimeZone=%ls\n", this, "Unattended::setTimeZone", aTimeZone));

    // Clear 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 TmpTimeZone(aTimeZone);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(KeyboardLayout)(BSTR *aKeyboardLayout)
{
    LogRelFlow(("{%p} %s: enter aKeyboardLayout=%p\n", this, "Unattended::getKeyboardLayout", aKeyboardLayout));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyboardLayout);
        BSTROutConverter TmpKeyboardLayout(aKeyboardLayout);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDLAYOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyboardLayout(TmpKeyboardLayout.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDLAYOUT_RETURN(this, hrc, 0 /*normal*/,TmpKeyboardLayout.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDLAYOUT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDLAYOUT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(KeyboardLayout)(IN_BSTR aKeyboardLayout)
{
    LogRelFlow(("{%p} %s: enter aKeyboardLayout=%ls\n", this, "Unattended::setKeyboardLayout", aKeyboardLayout));

    // Clear 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 TmpKeyboardLayout(aKeyboardLayout);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(KeyboardVariant)(BSTR *aKeyboardVariant)
{
    LogRelFlow(("{%p} %s: enter aKeyboardVariant=%p\n", this, "Unattended::getKeyboardVariant", aKeyboardVariant));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyboardVariant);
        BSTROutConverter TmpKeyboardVariant(aKeyboardVariant);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDVARIANT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyboardVariant(TmpKeyboardVariant.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDVARIANT_RETURN(this, hrc, 0 /*normal*/,TmpKeyboardVariant.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDVARIANT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_KEYBOARDVARIANT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(KeyboardVariant)(IN_BSTR aKeyboardVariant)
{
    LogRelFlow(("{%p} %s: enter aKeyboardVariant=%ls\n", this, "Unattended::setKeyboardVariant", aKeyboardVariant));

    // Clear 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 TmpKeyboardVariant(aKeyboardVariant);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Locale)(BSTR *aLocale)
{
    LogRelFlow(("{%p} %s: enter aLocale=%p\n", this, "Unattended::getLocale", aLocale));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLocale);
        BSTROutConverter TmpLocale(aLocale);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LOCALE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLocale(TmpLocale.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LOCALE_RETURN(this, hrc, 0 /*normal*/,TmpLocale.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LOCALE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LOCALE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Locale)(IN_BSTR aLocale)
{
    LogRelFlow(("{%p} %s: enter aLocale=%ls\n", this, "Unattended::setLocale", aLocale));

    // Clear 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 TmpLocale(aLocale);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Language)(BSTR *aLanguage)
{
    LogRelFlow(("{%p} %s: enter aLanguage=%p\n", this, "Unattended::getLanguage", aLanguage));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLanguage);
        BSTROutConverter TmpLanguage(aLanguage);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LANGUAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLanguage(TmpLanguage.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LANGUAGE_RETURN(this, hrc, 0 /*normal*/,TmpLanguage.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LANGUAGE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_LANGUAGE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Language)(IN_BSTR aLanguage)
{
    LogRelFlow(("{%p} %s: enter aLanguage=%ls\n", this, "Unattended::setLanguage", aLanguage));

    // Clear 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 TmpLanguage(aLanguage);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Country)(BSTR *aCountry)
{
    LogRelFlow(("{%p} %s: enter aCountry=%p\n", this, "Unattended::getCountry", aCountry));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCountry);
        BSTROutConverter TmpCountry(aCountry);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_COUNTRY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCountry(TmpCountry.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_COUNTRY_RETURN(this, hrc, 0 /*normal*/,TmpCountry.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_COUNTRY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_COUNTRY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Country)(IN_BSTR aCountry)
{
    LogRelFlow(("{%p} %s: enter aCountry=%ls\n", this, "Unattended::setCountry", aCountry));

    // Clear 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 TmpCountry(aCountry);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Proxy)(BSTR *aProxy)
{
    LogRelFlow(("{%p} %s: enter aProxy=%p\n", this, "Unattended::getProxy", aProxy));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProxy);
        BSTROutConverter TmpProxy(aProxy);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PROXY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProxy(TmpProxy.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PROXY_RETURN(this, hrc, 0 /*normal*/,TmpProxy.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PROXY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PROXY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Proxy)(IN_BSTR aProxy)
{
    LogRelFlow(("{%p} %s: enter aProxy=%ls\n", this, "Unattended::setProxy", aProxy));

    // Clear 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 TmpProxy(aProxy);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(PackageSelectionAdjustments)(BSTR *aPackageSelectionAdjustments)
{
    LogRelFlow(("{%p} %s: enter aPackageSelectionAdjustments=%p\n", this, "Unattended::getPackageSelectionAdjustments", aPackageSelectionAdjustments));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPackageSelectionAdjustments);
        BSTROutConverter TmpPackageSelectionAdjustments(aPackageSelectionAdjustments);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PACKAGESELECTIONADJUSTMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPackageSelectionAdjustments(TmpPackageSelectionAdjustments.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PACKAGESELECTIONADJUSTMENTS_RETURN(this, hrc, 0 /*normal*/,TmpPackageSelectionAdjustments.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PACKAGESELECTIONADJUSTMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_PACKAGESELECTIONADJUSTMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(PackageSelectionAdjustments)(IN_BSTR aPackageSelectionAdjustments)
{
    LogRelFlow(("{%p} %s: enter aPackageSelectionAdjustments=%ls\n", this, "Unattended::setPackageSelectionAdjustments", aPackageSelectionAdjustments));

    // Clear 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 TmpPackageSelectionAdjustments(aPackageSelectionAdjustments);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(Hostname)(BSTR *aHostname)
{
    LogRelFlow(("{%p} %s: enter aHostname=%p\n", this, "Unattended::getHostname", aHostname));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostname);
        BSTROutConverter TmpHostname(aHostname);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_HOSTNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostname(TmpHostname.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_HOSTNAME_RETURN(this, hrc, 0 /*normal*/,TmpHostname.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_HOSTNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_HOSTNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(Hostname)(IN_BSTR aHostname)
{
    LogRelFlow(("{%p} %s: enter aHostname=%ls\n", this, "Unattended::setHostname", aHostname));

    // Clear 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 TmpHostname(aHostname);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(AuxiliaryBasePath)(BSTR *aAuxiliaryBasePath)
{
    LogRelFlow(("{%p} %s: enter aAuxiliaryBasePath=%p\n", this, "Unattended::getAuxiliaryBasePath", aAuxiliaryBasePath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuxiliaryBasePath);
        BSTROutConverter TmpAuxiliaryBasePath(aAuxiliaryBasePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_AUXILIARYBASEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuxiliaryBasePath(TmpAuxiliaryBasePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_AUXILIARYBASEPATH_RETURN(this, hrc, 0 /*normal*/,TmpAuxiliaryBasePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_AUXILIARYBASEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_AUXILIARYBASEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(AuxiliaryBasePath)(IN_BSTR aAuxiliaryBasePath)
{
    LogRelFlow(("{%p} %s: enter aAuxiliaryBasePath=%ls\n", this, "Unattended::setAuxiliaryBasePath", aAuxiliaryBasePath));

    // Clear 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 TmpAuxiliaryBasePath(aAuxiliaryBasePath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(ImageIndex)(ULONG *aImageIndex)
{
    LogRelFlow(("{%p} %s: enter aImageIndex=%p\n", this, "Unattended::getImageIndex", aImageIndex));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMSETTER(ImageIndex)(ULONG aImageIndex)
{
    LogRelFlow(("{%p} %s: enter aImageIndex=%RU32\n", this, "Unattended::setImageIndex", aImageIndex));

    // Clear 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_UNATTENDED_SET_IMAGEINDEX_ENTER(this, aImageIndex);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setImageIndex(aImageIndex);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_IMAGEINDEX_RETURN(this, hrc, 0 /*normal*/,aImageIndex);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_IMAGEINDEX_RETURN(this, hrc, 1 /*hrc exception*/,aImageIndex);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_IMAGEINDEX_RETURN(this, hrc, 9 /*unhandled exception*/,aImageIndex);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(ScriptTemplatePath)(BSTR *aScriptTemplatePath)
{
    LogRelFlow(("{%p} %s: enter aScriptTemplatePath=%p\n", this, "Unattended::getScriptTemplatePath", aScriptTemplatePath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScriptTemplatePath);
        BSTROutConverter TmpScriptTemplatePath(aScriptTemplatePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_SCRIPTTEMPLATEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScriptTemplatePath(TmpScriptTemplatePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_SCRIPTTEMPLATEPATH_RETURN(this, hrc, 0 /*normal*/,TmpScriptTemplatePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_SCRIPTTEMPLATEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_SCRIPTTEMPLATEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(ScriptTemplatePath)(IN_BSTR aScriptTemplatePath)
{
    LogRelFlow(("{%p} %s: enter aScriptTemplatePath=%ls\n", this, "Unattended::setScriptTemplatePath", aScriptTemplatePath));

    // Clear 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 TmpScriptTemplatePath(aScriptTemplatePath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(PostInstallScriptTemplatePath)(BSTR *aPostInstallScriptTemplatePath)
{
    LogRelFlow(("{%p} %s: enter aPostInstallScriptTemplatePath=%p\n", this, "Unattended::getPostInstallScriptTemplatePath", aPostInstallScriptTemplatePath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPostInstallScriptTemplatePath);
        BSTROutConverter TmpPostInstallScriptTemplatePath(aPostInstallScriptTemplatePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLSCRIPTTEMPLATEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPostInstallScriptTemplatePath(TmpPostInstallScriptTemplatePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLSCRIPTTEMPLATEPATH_RETURN(this, hrc, 0 /*normal*/,TmpPostInstallScriptTemplatePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLSCRIPTTEMPLATEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLSCRIPTTEMPLATEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(PostInstallScriptTemplatePath)(IN_BSTR aPostInstallScriptTemplatePath)
{
    LogRelFlow(("{%p} %s: enter aPostInstallScriptTemplatePath=%ls\n", this, "Unattended::setPostInstallScriptTemplatePath", aPostInstallScriptTemplatePath));

    // Clear 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 TmpPostInstallScriptTemplatePath(aPostInstallScriptTemplatePath);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(PostInstallCommand)(BSTR *aPostInstallCommand)
{
    LogRelFlow(("{%p} %s: enter aPostInstallCommand=%p\n", this, "Unattended::getPostInstallCommand", aPostInstallCommand));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPostInstallCommand);
        BSTROutConverter TmpPostInstallCommand(aPostInstallCommand);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLCOMMAND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPostInstallCommand(TmpPostInstallCommand.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLCOMMAND_RETURN(this, hrc, 0 /*normal*/,TmpPostInstallCommand.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLCOMMAND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_POSTINSTALLCOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(PostInstallCommand)(IN_BSTR aPostInstallCommand)
{
    LogRelFlow(("{%p} %s: enter aPostInstallCommand=%ls\n", this, "Unattended::setPostInstallCommand", aPostInstallCommand));

    // Clear 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 TmpPostInstallCommand(aPostInstallCommand);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(ExtraInstallKernelParameters)(BSTR *aExtraInstallKernelParameters)
{
    LogRelFlow(("{%p} %s: enter aExtraInstallKernelParameters=%p\n", this, "Unattended::getExtraInstallKernelParameters", aExtraInstallKernelParameters));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtraInstallKernelParameters);
        BSTROutConverter TmpExtraInstallKernelParameters(aExtraInstallKernelParameters);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_EXTRAINSTALLKERNELPARAMETERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtraInstallKernelParameters(TmpExtraInstallKernelParameters.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_EXTRAINSTALLKERNELPARAMETERS_RETURN(this, hrc, 0 /*normal*/,TmpExtraInstallKernelParameters.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_EXTRAINSTALLKERNELPARAMETERS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_EXTRAINSTALLKERNELPARAMETERS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMSETTER(ExtraInstallKernelParameters)(IN_BSTR aExtraInstallKernelParameters)
{
    LogRelFlow(("{%p} %s: enter aExtraInstallKernelParameters=%ls\n", this, "Unattended::setExtraInstallKernelParameters", aExtraInstallKernelParameters));

    // Clear 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 TmpExtraInstallKernelParameters(aExtraInstallKernelParameters);

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedOSTypeId)(BSTR *aDetectedOSTypeId)
{
    LogRelFlow(("{%p} %s: enter aDetectedOSTypeId=%p\n", this, "Unattended::getDetectedOSTypeId", aDetectedOSTypeId));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedOSTypeId);
        BSTROutConverter TmpDetectedOSTypeId(aDetectedOSTypeId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSTYPEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedOSTypeId(TmpDetectedOSTypeId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSTYPEID_RETURN(this, hrc, 0 /*normal*/,TmpDetectedOSTypeId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSTYPEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSTYPEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedOSVersion)(BSTR *aDetectedOSVersion)
{
    LogRelFlow(("{%p} %s: enter aDetectedOSVersion=%p\n", this, "Unattended::getDetectedOSVersion", aDetectedOSVersion));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedOSVersion);
        BSTROutConverter TmpDetectedOSVersion(aDetectedOSVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedOSVersion(TmpDetectedOSVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSVERSION_RETURN(this, hrc, 0 /*normal*/,TmpDetectedOSVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedOSFlavor)(BSTR *aDetectedOSFlavor)
{
    LogRelFlow(("{%p} %s: enter aDetectedOSFlavor=%p\n", this, "Unattended::getDetectedOSFlavor", aDetectedOSFlavor));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedOSFlavor);
        BSTROutConverter TmpDetectedOSFlavor(aDetectedOSFlavor);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSFLAVOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedOSFlavor(TmpDetectedOSFlavor.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSFLAVOR_RETURN(this, hrc, 0 /*normal*/,TmpDetectedOSFlavor.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSFLAVOR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSFLAVOR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedOSLanguages)(BSTR *aDetectedOSLanguages)
{
    LogRelFlow(("{%p} %s: enter aDetectedOSLanguages=%p\n", this, "Unattended::getDetectedOSLanguages", aDetectedOSLanguages));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedOSLanguages);
        BSTROutConverter TmpDetectedOSLanguages(aDetectedOSLanguages);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSLANGUAGES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedOSLanguages(TmpDetectedOSLanguages.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSLANGUAGES_RETURN(this, hrc, 0 /*normal*/,TmpDetectedOSLanguages.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSLANGUAGES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSLANGUAGES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedOSHints)(BSTR *aDetectedOSHints)
{
    LogRelFlow(("{%p} %s: enter aDetectedOSHints=%p\n", this, "Unattended::getDetectedOSHints", aDetectedOSHints));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedOSHints);
        BSTROutConverter TmpDetectedOSHints(aDetectedOSHints);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSHINTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedOSHints(TmpDetectedOSHints.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSHINTS_RETURN(this, hrc, 0 /*normal*/,TmpDetectedOSHints.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSHINTS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDOSHINTS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedImageNames)(ComSafeArrayOut(BSTR, aDetectedImageNames))
{
    LogRelFlow(("{%p} %s: enter aDetectedImageNames=%p\n", this, "Unattended::getDetectedImageNames", aDetectedImageNames));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(DetectedImageIndices)(ComSafeArrayOut(ULONG, aDetectedImageIndices))
{
    LogRelFlow(("{%p} %s: enter aDetectedImageIndices=%p\n", this, "Unattended::getDetectedImageIndices", aDetectedImageIndices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDetectedImageIndices);
        ArrayOutConverter<ULONG> TmpDetectedImageIndices(ComSafeArrayOutArg(aDetectedImageIndices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDIMAGEINDICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDetectedImageIndices(TmpDetectedImageIndices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDIMAGEINDICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDetectedImageIndices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDIMAGEINDICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_GET_DETECTEDIMAGEINDICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(IsUnattendedInstallSupported)(BOOL *aIsUnattendedInstallSupported)
{
    LogRelFlow(("{%p} %s: enter aIsUnattendedInstallSupported=%p\n", this, "Unattended::getIsUnattendedInstallSupported", aIsUnattendedInstallSupported));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMGETTER(AvoidUpdatesOverNetwork)(BOOL *aAvoidUpdatesOverNetwork)
{
    LogRelFlow(("{%p} %s: enter aAvoidUpdatesOverNetwork=%p\n", this, "Unattended::getAvoidUpdatesOverNetwork", aAvoidUpdatesOverNetwork));

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

    HRESULT hrc;

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

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

STDMETHODIMP UnattendedWrap::COMSETTER(AvoidUpdatesOverNetwork)(BOOL aAvoidUpdatesOverNetwork)
{
    LogRelFlow(("{%p} %s: enter aAvoidUpdatesOverNetwork=%RTbool\n", this, "Unattended::setAvoidUpdatesOverNetwork", aAvoidUpdatesOverNetwork));

    // Clear 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_UNATTENDED_SET_AVOIDUPDATESOVERNETWORK_ENTER(this, aAvoidUpdatesOverNetwork != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAvoidUpdatesOverNetwork(aAvoidUpdatesOverNetwork != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_AVOIDUPDATESOVERNETWORK_RETURN(this, hrc, 0 /*normal*/,aAvoidUpdatesOverNetwork != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_AVOIDUPDATESOVERNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,aAvoidUpdatesOverNetwork != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_SET_AVOIDUPDATESOVERNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,aAvoidUpdatesOverNetwork != FALSE);
#endif
    }

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

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute1IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute2IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute3IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute4IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute5IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute6IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute7IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute8IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute9IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute10IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute11IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute12IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute13IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute14IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute15IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::COMGETTER(InternalAndReservedAttribute16IUnattended)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUnattended methods
//

STDMETHODIMP UnattendedWrap::DetectIsoOS()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Unattended::detectIsoOS"));

    // Clear 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_UNATTENDED_DETECTISOOS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detectIsoOS();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DETECTISOOS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DETECTISOOS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DETECTISOOS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UnattendedWrap::Prepare()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Unattended::prepare"));

    // Clear 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_UNATTENDED_PREPARE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = prepare();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_PREPARE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_PREPARE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_PREPARE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UnattendedWrap::ConstructMedia()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Unattended::constructMedia"));

    // Clear 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_UNATTENDED_CONSTRUCTMEDIA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = constructMedia();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_CONSTRUCTMEDIA_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_CONSTRUCTMEDIA_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_CONSTRUCTMEDIA_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UnattendedWrap::ReconfigureVM()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Unattended::reconfigureVM"));

    // Clear 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_UNATTENDED_RECONFIGUREVM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reconfigureVM();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_RECONFIGUREVM_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_RECONFIGUREVM_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_RECONFIGUREVM_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UnattendedWrap::Done()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Unattended::done"));

    // Clear 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_UNATTENDED_DONE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = done();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DONE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DONE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UNATTENDED_DONE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UnattendedWrap::InternalAndReservedMethod1IUnattended()
{
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::InternalAndReservedMethod2IUnattended()
{
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::InternalAndReservedMethod3IUnattended()
{
    return E_NOTIMPL;
}

STDMETHODIMP UnattendedWrap::InternalAndReservedMethod4IUnattended()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(UnattendedWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(UnattendedWrap, IUnattended)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "UnattendedWrap.cpp"


// ##### BEGINFILE "GraphicsAdapterWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGraphicsAdapter.
 *
 * 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_GRAPHICSADAPTER

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

DEFINE_EMPTY_CTOR_DTOR(GraphicsAdapterWrap)

//
// IGraphicsAdapter properties
//

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(GraphicsControllerType)(GraphicsControllerType_T *aGraphicsControllerType)
{
    LogRelFlow(("{%p} %s: enter aGraphicsControllerType=%p\n", this, "GraphicsAdapter::getGraphicsControllerType", aGraphicsControllerType));

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

    HRESULT hrc;

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

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

STDMETHODIMP GraphicsAdapterWrap::COMSETTER(GraphicsControllerType)(GraphicsControllerType_T aGraphicsControllerType)
{
    LogRelFlow(("{%p} %s: enter aGraphicsControllerType=%RU32\n", this, "GraphicsAdapter::setGraphicsControllerType", aGraphicsControllerType));

    // Clear 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_GRAPHICSADAPTER_SET_GRAPHICSCONTROLLERTYPE_ENTER(this, aGraphicsControllerType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setGraphicsControllerType(aGraphicsControllerType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_GRAPHICSCONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/,aGraphicsControllerType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_GRAPHICSCONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aGraphicsControllerType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_GRAPHICSCONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aGraphicsControllerType);
#endif
    }

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

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(VRAMSize)(ULONG *aVRAMSize)
{
    LogRelFlow(("{%p} %s: enter aVRAMSize=%p\n", this, "GraphicsAdapter::getVRAMSize", aVRAMSize));

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

    HRESULT hrc;

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

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

STDMETHODIMP GraphicsAdapterWrap::COMSETTER(VRAMSize)(ULONG aVRAMSize)
{
    LogRelFlow(("{%p} %s: enter aVRAMSize=%RU32\n", this, "GraphicsAdapter::setVRAMSize", aVRAMSize));

    // Clear 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_GRAPHICSADAPTER_SET_VRAMSIZE_ENTER(this, aVRAMSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRAMSize(aVRAMSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_VRAMSIZE_RETURN(this, hrc, 0 /*normal*/,aVRAMSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_VRAMSIZE_RETURN(this, hrc, 1 /*hrc exception*/,aVRAMSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_VRAMSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aVRAMSize);
#endif
    }

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

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(MonitorCount)(ULONG *aMonitorCount)
{
    LogRelFlow(("{%p} %s: enter aMonitorCount=%p\n", this, "GraphicsAdapter::getMonitorCount", aMonitorCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP GraphicsAdapterWrap::COMSETTER(MonitorCount)(ULONG aMonitorCount)
{
    LogRelFlow(("{%p} %s: enter aMonitorCount=%RU32\n", this, "GraphicsAdapter::setMonitorCount", aMonitorCount));

    // Clear 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_GRAPHICSADAPTER_SET_MONITORCOUNT_ENTER(this, aMonitorCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMonitorCount(aMonitorCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_MONITORCOUNT_RETURN(this, hrc, 0 /*normal*/,aMonitorCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_MONITORCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aMonitorCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SET_MONITORCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aMonitorCount);
#endif
    }

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

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute1IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute2IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute3IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute4IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute5IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute6IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute7IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::COMGETTER(InternalAndReservedAttribute8IGraphicsAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGraphicsAdapter methods
//

STDMETHODIMP GraphicsAdapterWrap::SetFeature(GraphicsFeature_T aFeature,
                                             BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aFeature=%RU32 aEnabled=%RTbool\n", this, "GraphicsAdapter::setFeature", aFeature, 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_GRAPHICSADAPTER_SETFEATURE_ENTER(this, aFeature, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFeature(aFeature,
                             aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SETFEATURE_RETURN(this, hrc, 0 /*normal*/, aFeature, aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SETFEATURE_RETURN(this, hrc, 1 /*hrc exception*/, aFeature, aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_SETFEATURE_RETURN(this, hrc, 9 /*unhandled exception*/, aFeature, aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP GraphicsAdapterWrap::IsFeatureEnabled(GraphicsFeature_T aFeature,
                                                   BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aFeature=%RU32 aEnabled=%p\n", this, "GraphicsAdapter::isFeatureEnabled", aFeature, 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_GRAPHICSADAPTER_ISFEATUREENABLED_ENTER(this, aFeature);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFeatureEnabled(aFeature,
                                   aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_ISFEATUREENABLED_RETURN(this, hrc, 0 /*normal*/, aFeature, *aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_ISFEATUREENABLED_RETURN(this, hrc, 1 /*hrc exception*/, aFeature, *aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GRAPHICSADAPTER_ISFEATUREENABLED_RETURN(this, hrc, 9 /*unhandled exception*/, aFeature, *aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP GraphicsAdapterWrap::InternalAndReservedMethod1IGraphicsAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::InternalAndReservedMethod2IGraphicsAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::InternalAndReservedMethod3IGraphicsAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP GraphicsAdapterWrap::InternalAndReservedMethod4IGraphicsAdapter()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GraphicsAdapterWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GraphicsAdapterWrap, IGraphicsAdapter)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GraphicsAdapterWrap.cpp"


// ##### BEGINFILE "RecordingScreenSettingsWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IRecordingScreenSettings.
 *
 * 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_RECORDINGSCREENSETTINGS

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

DEFINE_EMPTY_CTOR_DTOR(RecordingScreenSettingsWrap)

//
// IRecordingScreenSettings properties
//

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "RecordingScreenSettings::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_RECORDINGSCREENSETTINGS_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "RecordingScreenSettings::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_RECORDINGSCREENSETTINGS_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "RecordingScreenSettings::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_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Features)(ComSafeArrayOut(RecordingFeature_T, aFeatures))
{
    LogRelFlow(("{%p} %s: enter aFeatures=%p\n", this, "RecordingScreenSettings::getFeatures", aFeatures));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFeatures);
        ArrayOutConverter<RecordingFeature_T> TmpFeatures(ComSafeArrayOutArg(aFeatures));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_FEATURES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFeatures(TmpFeatures.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_FEATURES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFeatures.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_FEATURES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_FEATURES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(Features)(ComSafeArrayIn(RecordingFeature_T, aFeatures))
{
    LogRelFlow(("{%p} %s: enter aFeatures=%zu\n", this, "RecordingScreenSettings::setFeatures", ComSafeArraySize(aFeatures)));

    // Clear 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<RecordingFeature_T> TmpFeatures(ComSafeArrayInArg(aFeatures));

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Destination)(RecordingDestination_T *aDestination)
{
    LogRelFlow(("{%p} %s: enter aDestination=%p\n", this, "RecordingScreenSettings::getDestination", aDestination));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(Destination)(RecordingDestination_T aDestination)
{
    LogRelFlow(("{%p} %s: enter aDestination=%RU32\n", this, "RecordingScreenSettings::setDestination", aDestination));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_DESTINATION_ENTER(this, aDestination);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDestination(aDestination);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_DESTINATION_RETURN(this, hrc, 0 /*normal*/,aDestination);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_DESTINATION_RETURN(this, hrc, 1 /*hrc exception*/,aDestination);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_DESTINATION_RETURN(this, hrc, 9 /*unhandled exception*/,aDestination);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Filename)(BSTR *aFilename)
{
    LogRelFlow(("{%p} %s: enter aFilename=%p\n", this, "RecordingScreenSettings::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_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_GET_FILENAME_RETURN(this, hrc, 0 /*normal*/,TmpFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_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_RECORDINGSCREENSETTINGS_GET_FILENAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(Filename)(IN_BSTR aFilename)
{
    LogRelFlow(("{%p} %s: enter aFilename=%ls\n", this, "RecordingScreenSettings::setFilename", 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
    {
        BSTRInConverter TmpFilename(aFilename);

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(MaxTime)(ULONG *aMaxTime)
{
    LogRelFlow(("{%p} %s: enter aMaxTime=%p\n", this, "RecordingScreenSettings::getMaxTime", aMaxTime));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(MaxTime)(ULONG aMaxTime)
{
    LogRelFlow(("{%p} %s: enter aMaxTime=%RU32\n", this, "RecordingScreenSettings::setMaxTime", aMaxTime));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_MAXTIME_ENTER(this, aMaxTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaxTime(aMaxTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXTIME_RETURN(this, hrc, 0 /*normal*/,aMaxTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXTIME_RETURN(this, hrc, 1 /*hrc exception*/,aMaxTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXTIME_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxTime);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(MaxFileSize)(ULONG *aMaxFileSize)
{
    LogRelFlow(("{%p} %s: enter aMaxFileSize=%p\n", this, "RecordingScreenSettings::getMaxFileSize", aMaxFileSize));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(MaxFileSize)(ULONG aMaxFileSize)
{
    LogRelFlow(("{%p} %s: enter aMaxFileSize=%RU32\n", this, "RecordingScreenSettings::setMaxFileSize", aMaxFileSize));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_MAXFILESIZE_ENTER(this, aMaxFileSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaxFileSize(aMaxFileSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXFILESIZE_RETURN(this, hrc, 0 /*normal*/,aMaxFileSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXFILESIZE_RETURN(this, hrc, 1 /*hrc exception*/,aMaxFileSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_MAXFILESIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxFileSize);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(Options)(BSTR *aOptions)
{
    LogRelFlow(("{%p} %s: enter aOptions=%p\n", this, "RecordingScreenSettings::getOptions", aOptions));

    // Clear error 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);
        BSTROutConverter TmpOptions(aOptions);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_OPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOptions(TmpOptions.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_OPTIONS_RETURN(this, hrc, 0 /*normal*/,TmpOptions.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_OPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_GET_OPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(Options)(IN_BSTR aOptions)
{
    LogRelFlow(("{%p} %s: enter aOptions=%ls\n", this, "RecordingScreenSettings::setOptions", aOptions));

    // Clear 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 TmpOptions(aOptions);

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioCodec)(RecordingAudioCodec_T *aAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aAudioCodec=%p\n", this, "RecordingScreenSettings::getAudioCodec", aAudioCodec));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioCodec)(RecordingAudioCodec_T aAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aAudioCodec=%RU32\n", this, "RecordingScreenSettings::setAudioCodec", aAudioCodec));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIOCODEC_ENTER(this, aAudioCodec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioCodec(aAudioCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCODEC_RETURN(this, hrc, 0 /*normal*/,aAudioCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,aAudioCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioCodec);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioRateControlMode)(RecordingRateControlMode_T *aAudioRateControlMode)
{
    LogRelFlow(("{%p} %s: enter aAudioRateControlMode=%p\n", this, "RecordingScreenSettings::getAudioRateControlMode", aAudioRateControlMode));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioRateControlMode)(RecordingRateControlMode_T aAudioRateControlMode)
{
    LogRelFlow(("{%p} %s: enter aAudioRateControlMode=%RU32\n", this, "RecordingScreenSettings::setAudioRateControlMode", aAudioRateControlMode));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIORATECONTROLMODE_ENTER(this, aAudioRateControlMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioRateControlMode(aAudioRateControlMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIORATECONTROLMODE_RETURN(this, hrc, 0 /*normal*/,aAudioRateControlMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIORATECONTROLMODE_RETURN(this, hrc, 1 /*hrc exception*/,aAudioRateControlMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIORATECONTROLMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioRateControlMode);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioDeadline)(RecordingCodecDeadline_T *aAudioDeadline)
{
    LogRelFlow(("{%p} %s: enter aAudioDeadline=%p\n", this, "RecordingScreenSettings::getAudioDeadline", aAudioDeadline));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioDeadline)(RecordingCodecDeadline_T aAudioDeadline)
{
    LogRelFlow(("{%p} %s: enter aAudioDeadline=%RU32\n", this, "RecordingScreenSettings::setAudioDeadline", aAudioDeadline));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIODEADLINE_ENTER(this, aAudioDeadline);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioDeadline(aAudioDeadline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIODEADLINE_RETURN(this, hrc, 0 /*normal*/,aAudioDeadline);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIODEADLINE_RETURN(this, hrc, 1 /*hrc exception*/,aAudioDeadline);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIODEADLINE_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioDeadline);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioHz)(ULONG *aAudioHz)
{
    LogRelFlow(("{%p} %s: enter aAudioHz=%p\n", this, "RecordingScreenSettings::getAudioHz", aAudioHz));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioHz)(ULONG aAudioHz)
{
    LogRelFlow(("{%p} %s: enter aAudioHz=%RU32\n", this, "RecordingScreenSettings::setAudioHz", aAudioHz));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIOHZ_ENTER(this, aAudioHz);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioHz(aAudioHz);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOHZ_RETURN(this, hrc, 0 /*normal*/,aAudioHz);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOHZ_RETURN(this, hrc, 1 /*hrc exception*/,aAudioHz);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOHZ_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioHz);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioBits)(ULONG *aAudioBits)
{
    LogRelFlow(("{%p} %s: enter aAudioBits=%p\n", this, "RecordingScreenSettings::getAudioBits", aAudioBits));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioBits)(ULONG aAudioBits)
{
    LogRelFlow(("{%p} %s: enter aAudioBits=%RU32\n", this, "RecordingScreenSettings::setAudioBits", aAudioBits));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIOBITS_ENTER(this, aAudioBits);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioBits(aAudioBits);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOBITS_RETURN(this, hrc, 0 /*normal*/,aAudioBits);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOBITS_RETURN(this, hrc, 1 /*hrc exception*/,aAudioBits);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOBITS_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioBits);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(AudioChannels)(ULONG *aAudioChannels)
{
    LogRelFlow(("{%p} %s: enter aAudioChannels=%p\n", this, "RecordingScreenSettings::getAudioChannels", aAudioChannels));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(AudioChannels)(ULONG aAudioChannels)
{
    LogRelFlow(("{%p} %s: enter aAudioChannels=%RU32\n", this, "RecordingScreenSettings::setAudioChannels", aAudioChannels));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_AUDIOCHANNELS_ENTER(this, aAudioChannels);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioChannels(aAudioChannels);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCHANNELS_RETURN(this, hrc, 0 /*normal*/,aAudioChannels);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCHANNELS_RETURN(this, hrc, 1 /*hrc exception*/,aAudioChannels);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_AUDIOCHANNELS_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioChannels);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoCodec)(RecordingVideoCodec_T *aVideoCodec)
{
    LogRelFlow(("{%p} %s: enter aVideoCodec=%p\n", this, "RecordingScreenSettings::getVideoCodec", aVideoCodec));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoCodec)(RecordingVideoCodec_T aVideoCodec)
{
    LogRelFlow(("{%p} %s: enter aVideoCodec=%RU32\n", this, "RecordingScreenSettings::setVideoCodec", aVideoCodec));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEOCODEC_ENTER(this, aVideoCodec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoCodec(aVideoCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOCODEC_RETURN(this, hrc, 0 /*normal*/,aVideoCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,aVideoCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoCodec);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoDeadline)(RecordingCodecDeadline_T *aVideoDeadline)
{
    LogRelFlow(("{%p} %s: enter aVideoDeadline=%p\n", this, "RecordingScreenSettings::getVideoDeadline", aVideoDeadline));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoDeadline)(RecordingCodecDeadline_T aVideoDeadline)
{
    LogRelFlow(("{%p} %s: enter aVideoDeadline=%RU32\n", this, "RecordingScreenSettings::setVideoDeadline", aVideoDeadline));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEODEADLINE_ENTER(this, aVideoDeadline);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoDeadline(aVideoDeadline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEODEADLINE_RETURN(this, hrc, 0 /*normal*/,aVideoDeadline);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEODEADLINE_RETURN(this, hrc, 1 /*hrc exception*/,aVideoDeadline);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEODEADLINE_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoDeadline);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoWidth)(ULONG *aVideoWidth)
{
    LogRelFlow(("{%p} %s: enter aVideoWidth=%p\n", this, "RecordingScreenSettings::getVideoWidth", aVideoWidth));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoWidth)(ULONG aVideoWidth)
{
    LogRelFlow(("{%p} %s: enter aVideoWidth=%RU32\n", this, "RecordingScreenSettings::setVideoWidth", aVideoWidth));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEOWIDTH_ENTER(this, aVideoWidth);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoWidth(aVideoWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOWIDTH_RETURN(this, hrc, 0 /*normal*/,aVideoWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOWIDTH_RETURN(this, hrc, 1 /*hrc exception*/,aVideoWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOWIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoWidth);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoHeight)(ULONG *aVideoHeight)
{
    LogRelFlow(("{%p} %s: enter aVideoHeight=%p\n", this, "RecordingScreenSettings::getVideoHeight", aVideoHeight));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoHeight)(ULONG aVideoHeight)
{
    LogRelFlow(("{%p} %s: enter aVideoHeight=%RU32\n", this, "RecordingScreenSettings::setVideoHeight", aVideoHeight));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEOHEIGHT_ENTER(this, aVideoHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoHeight(aVideoHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOHEIGHT_RETURN(this, hrc, 0 /*normal*/,aVideoHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOHEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,aVideoHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOHEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoHeight);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoRate)(ULONG *aVideoRate)
{
    LogRelFlow(("{%p} %s: enter aVideoRate=%p\n", this, "RecordingScreenSettings::getVideoRate", aVideoRate));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoRate)(ULONG aVideoRate)
{
    LogRelFlow(("{%p} %s: enter aVideoRate=%RU32\n", this, "RecordingScreenSettings::setVideoRate", aVideoRate));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEORATE_ENTER(this, aVideoRate);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoRate(aVideoRate);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATE_RETURN(this, hrc, 0 /*normal*/,aVideoRate);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATE_RETURN(this, hrc, 1 /*hrc exception*/,aVideoRate);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATE_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoRate);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoRateControlMode)(RecordingRateControlMode_T *aVideoRateControlMode)
{
    LogRelFlow(("{%p} %s: enter aVideoRateControlMode=%p\n", this, "RecordingScreenSettings::getVideoRateControlMode", aVideoRateControlMode));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoRateControlMode)(RecordingRateControlMode_T aVideoRateControlMode)
{
    LogRelFlow(("{%p} %s: enter aVideoRateControlMode=%RU32\n", this, "RecordingScreenSettings::setVideoRateControlMode", aVideoRateControlMode));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEORATECONTROLMODE_ENTER(this, aVideoRateControlMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoRateControlMode(aVideoRateControlMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATECONTROLMODE_RETURN(this, hrc, 0 /*normal*/,aVideoRateControlMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATECONTROLMODE_RETURN(this, hrc, 1 /*hrc exception*/,aVideoRateControlMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEORATECONTROLMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoRateControlMode);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoFPS)(ULONG *aVideoFPS)
{
    LogRelFlow(("{%p} %s: enter aVideoFPS=%p\n", this, "RecordingScreenSettings::getVideoFPS", aVideoFPS));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoFPS)(ULONG aVideoFPS)
{
    LogRelFlow(("{%p} %s: enter aVideoFPS=%RU32\n", this, "RecordingScreenSettings::setVideoFPS", aVideoFPS));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEOFPS_ENTER(this, aVideoFPS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoFPS(aVideoFPS);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOFPS_RETURN(this, hrc, 0 /*normal*/,aVideoFPS);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOFPS_RETURN(this, hrc, 1 /*hrc exception*/,aVideoFPS);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOFPS_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoFPS);
#endif
    }

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

STDMETHODIMP RecordingScreenSettingsWrap::COMGETTER(VideoScalingMode)(RecordingVideoScalingMode_T *aVideoScalingMode)
{
    LogRelFlow(("{%p} %s: enter aVideoScalingMode=%p\n", this, "RecordingScreenSettings::getVideoScalingMode", aVideoScalingMode));

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

    HRESULT hrc;

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

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

STDMETHODIMP RecordingScreenSettingsWrap::COMSETTER(VideoScalingMode)(RecordingVideoScalingMode_T aVideoScalingMode)
{
    LogRelFlow(("{%p} %s: enter aVideoScalingMode=%RU32\n", this, "RecordingScreenSettings::setVideoScalingMode", aVideoScalingMode));

    // Clear 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_RECORDINGSCREENSETTINGS_SET_VIDEOSCALINGMODE_ENTER(this, aVideoScalingMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoScalingMode(aVideoScalingMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOSCALINGMODE_RETURN(this, hrc, 0 /*normal*/,aVideoScalingMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOSCALINGMODE_RETURN(this, hrc, 1 /*hrc exception*/,aVideoScalingMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_SET_VIDEOSCALINGMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aVideoScalingMode);
#endif
    }

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


//
// IRecordingScreenSettings methods
//

STDMETHODIMP RecordingScreenSettingsWrap::IsFeatureEnabled(RecordingFeature_T aFeature,
                                                           BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aFeature=%RU32 aEnabled=%p\n", this, "RecordingScreenSettings::isFeatureEnabled", aFeature, 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_RECORDINGSCREENSETTINGS_ISFEATUREENABLED_ENTER(this, aFeature);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFeatureEnabled(aFeature,
                                   aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_ISFEATUREENABLED_RETURN(this, hrc, 0 /*normal*/, aFeature, *aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_ISFEATUREENABLED_RETURN(this, hrc, 1 /*hrc exception*/, aFeature, *aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSCREENSETTINGS_ISFEATUREENABLED_RETURN(this, hrc, 9 /*unhandled exception*/, aFeature, *aEnabled != FALSE);
#endif
    }

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

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(RecordingScreenSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(RecordingScreenSettingsWrap, IRecordingScreenSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "RecordingScreenSettingsWrap.cpp"


// ##### BEGINFILE "PCIAddressWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPCIAddress.
 *
 * 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_PCIADDRESS

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

DEFINE_EMPTY_CTOR_DTOR(PCIAddressWrap)

//
// IPCIAddress properties
//

STDMETHODIMP PCIAddressWrap::COMGETTER(Bus)(SHORT *aBus)
{
    LogRelFlow(("{%p} %s: enter aBus=%p\n", this, "PCIAddress::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_PCIADDRESS_GET_BUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBus(aBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_GET_BUS_RETURN(this, hrc, 0 /*normal*/,*aBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_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_PCIADDRESS_GET_BUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBus=%RI16 hrc=%Rhrc\n", this, "PCIAddress::getBus", !RT_VALID_PTR(aBus) ? 0 : *aBus, hrc));
    return hrc;
}

STDMETHODIMP PCIAddressWrap::COMSETTER(Bus)(SHORT aBus)
{
    LogRelFlow(("{%p} %s: enter aBus=%RI16\n", this, "PCIAddress::setBus", 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
    {
        

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

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

STDMETHODIMP PCIAddressWrap::COMGETTER(Device)(SHORT *aDevice)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p\n", this, "PCIAddress::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_PCIADDRESS_GET_DEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDevice(aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_GET_DEVICE_RETURN(this, hrc, 0 /*normal*/,*aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_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_PCIADDRESS_GET_DEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDevice=%RI16 hrc=%Rhrc\n", this, "PCIAddress::getDevice", !RT_VALID_PTR(aDevice) ? 0 : *aDevice, hrc));
    return hrc;
}

STDMETHODIMP PCIAddressWrap::COMSETTER(Device)(SHORT aDevice)
{
    LogRelFlow(("{%p} %s: enter aDevice=%RI16\n", this, "PCIAddress::setDevice", 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_PCIADDRESS_SET_DEVICE_ENTER(this, aDevice);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDevice(aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVICE_RETURN(this, hrc, 0 /*normal*/,aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVICE_RETURN(this, hrc, 1 /*hrc exception*/,aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,aDevice);
#endif
    }

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

STDMETHODIMP PCIAddressWrap::COMGETTER(DevFunction)(SHORT *aDevFunction)
{
    LogRelFlow(("{%p} %s: enter aDevFunction=%p\n", this, "PCIAddress::getDevFunction", aDevFunction));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aDevFunction=%RI16 hrc=%Rhrc\n", this, "PCIAddress::getDevFunction", !RT_VALID_PTR(aDevFunction) ? 0 : *aDevFunction, hrc));
    return hrc;
}

STDMETHODIMP PCIAddressWrap::COMSETTER(DevFunction)(SHORT aDevFunction)
{
    LogRelFlow(("{%p} %s: enter aDevFunction=%RI16\n", this, "PCIAddress::setDevFunction", aDevFunction));

    // Clear 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_PCIADDRESS_SET_DEVFUNCTION_ENTER(this, aDevFunction);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDevFunction(aDevFunction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVFUNCTION_RETURN(this, hrc, 0 /*normal*/,aDevFunction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVFUNCTION_RETURN(this, hrc, 1 /*hrc exception*/,aDevFunction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_SET_DEVFUNCTION_RETURN(this, hrc, 9 /*unhandled exception*/,aDevFunction);
#endif
    }

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


//
// IPCIAddress methods
//

STDMETHODIMP PCIAddressWrap::AsLong(LONG *aResult)
{
    LogRelFlow(("{%p} %s: enter aResult=%p\n", this, "PCIAddress::asLong", 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_PCIADDRESS_ASLONG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = asLong(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_ASLONG_RETURN(this, hrc, 0 /*normal*/, *aResult);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_ASLONG_RETURN(this, hrc, 1 /*hrc exception*/, *aResult);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIADDRESS_ASLONG_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RI32 hrc=%Rhrc\n", this, "PCIAddress::asLong", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

STDMETHODIMP PCIAddressWrap::FromLong(LONG aNumber)
{
    LogRelFlow(("{%p} %s: enter aNumber=%RI32\n", this, "PCIAddress::fromLong", 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
    {


        

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

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

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PCIAddressWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PCIAddressWrap, IPCIAddress)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PCIAddressWrap.cpp"


// ##### BEGINFILE "UefiVariableStoreWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUefiVariableStore.
 *
 * 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_UEFIVARIABLESTORE

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

DEFINE_EMPTY_CTOR_DTOR(UefiVariableStoreWrap)

//
// IUefiVariableStore properties
//

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(SecureBootEnabled)(BOOL *aSecureBootEnabled)
{
    LogRelFlow(("{%p} %s: enter aSecureBootEnabled=%p\n", this, "UefiVariableStore::getSecureBootEnabled", aSecureBootEnabled));

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

    HRESULT hrc;

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

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

STDMETHODIMP UefiVariableStoreWrap::COMSETTER(SecureBootEnabled)(BOOL aSecureBootEnabled)
{
    LogRelFlow(("{%p} %s: enter aSecureBootEnabled=%RTbool\n", this, "UefiVariableStore::setSecureBootEnabled", aSecureBootEnabled));

    // Clear 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_UEFIVARIABLESTORE_SET_SECUREBOOTENABLED_ENTER(this, aSecureBootEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSecureBootEnabled(aSecureBootEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_SET_SECUREBOOTENABLED_RETURN(this, hrc, 0 /*normal*/,aSecureBootEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_SET_SECUREBOOTENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aSecureBootEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_SET_SECUREBOOTENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aSecureBootEnabled != FALSE);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(InternalAndReservedAttribute1IUefiVariableStore)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(InternalAndReservedAttribute2IUefiVariableStore)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(InternalAndReservedAttribute3IUefiVariableStore)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(InternalAndReservedAttribute4IUefiVariableStore)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::COMGETTER(InternalAndReservedAttribute5IUefiVariableStore)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUefiVariableStore methods
//

STDMETHODIMP UefiVariableStoreWrap::AddVariable(IN_BSTR aName,
                                                IN_BSTR aOwner,
                                                ComSafeArrayIn(UefiVariableAttributes_T, aAttributes),
                                                ComSafeArrayIn(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aName=%ls aOwner=%ls aAttributes=%zu aData=%zu\n", this, "UefiVariableStore::addVariable", aName, aOwner, aAttributes, 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
    {


        BSTRInConverter TmpName(aName);
        UuidInConverter TmpOwner(aOwner);
        ArrayInConverter<UefiVariableAttributes_T> TmpAttributes(ComSafeArrayInArg(aAttributes));
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDVARIABLE_ENTER(this, TmpName.str().c_str(), TmpOwner.uuid().toStringCurly().c_str(), (uint32_t)TmpAttributes.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addVariable(TmpName.str(),
                              TmpOwner.uuid(),
                              TmpAttributes.array(),
                              TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDVARIABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpOwner.uuid().toStringCurly().c_str(), (uint32_t)TmpAttributes.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDVARIABLE_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_UEFIVARIABLESTORE_ADDVARIABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::DeleteVariable(IN_BSTR aName,
                                                   IN_BSTR aOwner)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aOwner=%ls\n", this, "UefiVariableStore::deleteVariable", aName, aOwner));

    // Clear 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);
        UuidInConverter TmpOwner(aOwner);

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

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

STDMETHODIMP UefiVariableStoreWrap::ChangeVariable(IN_BSTR aName,
                                                   ComSafeArrayIn(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aName=%ls aData=%zu\n", this, "UefiVariableStore::changeVariable", aName, 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
    {


        BSTRInConverter TmpName(aName);
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_CHANGEVARIABLE_ENTER(this, TmpName.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = changeVariable(TmpName.str(),
                                 TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_CHANGEVARIABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_CHANGEVARIABLE_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_UEFIVARIABLESTORE_CHANGEVARIABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::QueryVariableByName(IN_BSTR aName,
                                                        BSTR *aOwner,
                                                        ComSafeArrayOut(UefiVariableAttributes_T, aAttributes),
                                                        ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aName=%ls aOwner=%p aAttributes=%p aData=%p\n", this, "UefiVariableStore::queryVariableByName", aName, aOwner, aAttributes, 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(aOwner);
        CheckComArgOutPointerValidThrow(aAttributes);
        CheckComArgOutPointerValidThrow(aData);


        BSTRInConverter TmpName(aName);
        UuidOutConverter TmpOwner(aOwner);
        ArrayOutConverter<UefiVariableAttributes_T> TmpAttributes(ComSafeArrayOutArg(aAttributes));
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLEBYNAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryVariableByName(TmpName.str(),
                                      TmpOwner.uuid(),
                                      TmpAttributes.array(),
                                      TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLEBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpOwner.uuid().toStringCurly().c_str(), (uint32_t)TmpAttributes.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLEBYNAME_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_UEFIVARIABLESTORE_QUERYVARIABLEBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOwner=%ls *aAttributes=%zu *aData=%zu hrc=%Rhrc\n", this, "UefiVariableStore::queryVariableByName", !RT_VALID_PTR(aOwner) ? 0 : *aOwner, !RT_VALID_PTR(aAttributes) ? 0 : ComSafeArraySize(*aAttributes), !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP UefiVariableStoreWrap::QueryVariables(ComSafeArrayOut(BSTR, aNames),
                                                   ComSafeArrayOut(BSTR, aOwners))
{
    LogRelFlow(("{%p} %s: enter aNames=%p aOwners=%p\n", this, "UefiVariableStore::queryVariables", aNames, aOwners));

    // Clear error 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(aOwners);


        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayUuidOutConverter TmpOwners(ComSafeArrayOutArg(aOwners));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryVariables(TmpNames.array(),
                                 TmpOwners.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpOwners.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_QUERYVARIABLES_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_UEFIVARIABLESTORE_QUERYVARIABLES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aOwners=%zu hrc=%Rhrc\n", this, "UefiVariableStore::queryVariables", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aOwners) ? 0 : ComSafeArraySize(*aOwners), hrc));
    return hrc;
}

STDMETHODIMP UefiVariableStoreWrap::EnrollOraclePlatformKey()
{
    LogRelFlow(("{%p} %s: enter\n", this, "UefiVariableStore::enrollOraclePlatformKey"));

    // Clear 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_UEFIVARIABLESTORE_ENROLLORACLEPLATFORMKEY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enrollOraclePlatformKey();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLORACLEPLATFORMKEY_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLORACLEPLATFORMKEY_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLORACLEPLATFORMKEY_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::EnrollPlatformKey(ComSafeArrayIn(BYTE, aPlatformKey),
                                                      IN_BSTR aOwner)
{
    LogRelFlow(("{%p} %s: enter aPlatformKey=%zu aOwner=%ls\n", this, "UefiVariableStore::enrollPlatformKey", aPlatformKey, aOwner));

    // Clear 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> TmpPlatformKey(ComSafeArrayInArg(aPlatformKey));
        UuidInConverter TmpOwner(aOwner);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLPLATFORMKEY_ENTER(this, (uint32_t)TmpPlatformKey.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enrollPlatformKey(TmpPlatformKey.array(),
                                    TmpOwner.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLPLATFORMKEY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpPlatformKey.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLPLATFORMKEY_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_UEFIVARIABLESTORE_ENROLLPLATFORMKEY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::AddKek(ComSafeArrayIn(BYTE, aKeyEncryptionKey),
                                           IN_BSTR aOwner,
                                           SignatureType_T aSignatureType)
{
    LogRelFlow(("{%p} %s: enter aKeyEncryptionKey=%zu aOwner=%ls aSignatureType=%RU32\n", this, "UefiVariableStore::addKek", aKeyEncryptionKey, aOwner, aSignatureType));

    // Clear 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> TmpKeyEncryptionKey(ComSafeArrayInArg(aKeyEncryptionKey));
        UuidInConverter TmpOwner(aOwner);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDKEK_ENTER(this, (uint32_t)TmpKeyEncryptionKey.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addKek(TmpKeyEncryptionKey.array(),
                         TmpOwner.uuid(),
                         aSignatureType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDKEK_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpKeyEncryptionKey.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDKEK_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aSignatureType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDKEK_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aSignatureType);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::AddSignatureToDb(ComSafeArrayIn(BYTE, aSignature),
                                                     IN_BSTR aOwner,
                                                     SignatureType_T aSignatureType)
{
    LogRelFlow(("{%p} %s: enter aSignature=%zu aOwner=%ls aSignatureType=%RU32\n", this, "UefiVariableStore::addSignatureToDb", aSignature, aOwner, aSignatureType));

    // Clear 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> TmpSignature(ComSafeArrayInArg(aSignature));
        UuidInConverter TmpOwner(aOwner);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODB_ENTER(this, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addSignatureToDb(TmpSignature.array(),
                                   TmpOwner.uuid(),
                                   aSignatureType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODB_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODB_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aSignatureType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODB_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aSignatureType);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::AddSignatureToDbx(ComSafeArrayIn(BYTE, aSignature),
                                                      IN_BSTR aOwner,
                                                      SignatureType_T aSignatureType)
{
    LogRelFlow(("{%p} %s: enter aSignature=%zu aOwner=%ls aSignatureType=%RU32\n", this, "UefiVariableStore::addSignatureToDbx", aSignature, aOwner, aSignatureType));

    // Clear 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> TmpSignature(ComSafeArrayInArg(aSignature));
        UuidInConverter TmpOwner(aOwner);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODBX_ENTER(this, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addSignatureToDbx(TmpSignature.array(),
                                    TmpOwner.uuid(),
                                    aSignatureType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODBX_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODBX_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aSignatureType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETODBX_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aSignatureType);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::EnrollDefaultMsSignatures()
{
    LogRelFlow(("{%p} %s: enter\n", this, "UefiVariableStore::enrollDefaultMsSignatures"));

    // Clear 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_UEFIVARIABLESTORE_ENROLLDEFAULTMSSIGNATURES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enrollDefaultMsSignatures();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLDEFAULTMSSIGNATURES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLDEFAULTMSSIGNATURES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ENROLLDEFAULTMSSIGNATURES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::AddSignatureToMok(ComSafeArrayIn(BYTE, aSignature),
                                                      IN_BSTR aOwner,
                                                      SignatureType_T aSignatureType)
{
    LogRelFlow(("{%p} %s: enter aSignature=%zu aOwner=%ls aSignatureType=%RU32\n", this, "UefiVariableStore::addSignatureToMok", aSignature, aOwner, aSignatureType));

    // Clear 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> TmpSignature(ComSafeArrayInArg(aSignature));
        UuidInConverter TmpOwner(aOwner);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETOMOK_ENTER(this, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addSignatureToMok(TmpSignature.array(),
                                    TmpOwner.uuid(),
                                    aSignatureType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETOMOK_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSignature.array().size(), NULL /*for now*/, TmpOwner.uuid().toStringCurly().c_str(), aSignatureType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETOMOK_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aSignatureType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UEFIVARIABLESTORE_ADDSIGNATURETOMOK_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aSignatureType);
#endif
    }

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

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod1IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod2IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod3IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod4IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod5IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod6IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod7IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod8IUefiVariableStore()
{
    return E_NOTIMPL;
}

STDMETHODIMP UefiVariableStoreWrap::InternalAndReservedMethod9IUefiVariableStore()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(UefiVariableStoreWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(UefiVariableStoreWrap, IUefiVariableStore)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "UefiVariableStoreWrap.cpp"


// ##### BEGINFILE "ResourceStoreWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IResourceStore.
 *
 * 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_RESOURCESTORE

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

DEFINE_EMPTY_CTOR_DTOR(ResourceStoreWrap)

//
// IResourceStore properties
//

STDMETHODIMP ResourceStoreWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "ResourceStore::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, "ResourceStore::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IResourceStore methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ResourceStoreWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ResourceStoreWrap, IResourceStore)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ResourceStoreWrap.cpp"


// ##### BEGINFILE "PlatformX86Wrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPlatformX86.
 *
 * 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_PLATFORMX86

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

DEFINE_EMPTY_CTOR_DTOR(PlatformX86Wrap)

//
// IPlatformX86 properties
//

STDMETHODIMP PlatformX86Wrap::COMGETTER(HPETEnabled)(BOOL *aHPETEnabled)
{
    LogRelFlow(("{%p} %s: enter aHPETEnabled=%p\n", this, "PlatformX86::getHPETEnabled", aHPETEnabled));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformX86Wrap::COMSETTER(HPETEnabled)(BOOL aHPETEnabled)
{
    LogRelFlow(("{%p} %s: enter aHPETEnabled=%RTbool\n", this, "PlatformX86::setHPETEnabled", aHPETEnabled));

    // Clear 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_PLATFORMX86_SET_HPETENABLED_ENTER(this, aHPETEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHPETEnabled(aHPETEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SET_HPETENABLED_RETURN(this, hrc, 0 /*normal*/,aHPETEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SET_HPETENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aHPETEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SET_HPETENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aHPETEnabled != FALSE);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute1IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute2IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute3IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute4IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute5IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute6IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute7IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute8IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute9IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute10IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute11IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute12IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute13IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute14IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute15IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::COMGETTER(InternalAndReservedAttribute16IPlatformX86)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPlatformX86 methods
//

STDMETHODIMP PlatformX86Wrap::GetCPUProperty(CPUPropertyTypeX86_T aProperty,
                                             BOOL *aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%p\n", this, "PlatformX86::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_PLATFORMX86_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_PLATFORMX86_GETCPUPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, *aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_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_PLATFORMX86_GETCPUPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, *aValue != FALSE);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::SetCPUProperty(CPUPropertyTypeX86_T aProperty,
                                             BOOL aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%RTbool\n", this, "PlatformX86::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_PLATFORMX86_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_PLATFORMX86_SETCPUPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_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_PLATFORMX86_SETCPUPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, aValue != FALSE);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::GetCPUIDLeafByOrdinal(ULONG aOrdinal,
                                                    ULONG *aIdx,
                                                    ULONG *aIdxSub,
                                                    ULONG *aValEax,
                                                    ULONG *aValEbx,
                                                    ULONG *aValEcx,
                                                    ULONG *aValEdx)
{
    LogRelFlow(("{%p} %s: enter aOrdinal=%RU32 aIdx=%p aIdxSub=%p aValEax=%p aValEbx=%p aValEcx=%p aValEdx=%p\n", this, "PlatformX86::getCPUIDLeafByOrdinal", aOrdinal, aIdx, aIdxSub, 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(aIdx);
        CheckComArgOutPointerValidThrow(aIdxSub);
        CheckComArgOutPointerValidThrow(aValEax);
        CheckComArgOutPointerValidThrow(aValEbx);
        CheckComArgOutPointerValidThrow(aValEcx);
        CheckComArgOutPointerValidThrow(aValEdx);


        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAFBYORDINAL_ENTER(this, aOrdinal);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUIDLeafByOrdinal(aOrdinal,
                                        aIdx,
                                        aIdxSub,
                                        aValEax,
                                        aValEbx,
                                        aValEcx,
                                        aValEdx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAFBYORDINAL_RETURN(this, hrc, 0 /*normal*/, aOrdinal, *aIdx, *aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAFBYORDINAL_RETURN(this, hrc, 1 /*hrc exception*/, aOrdinal, *aIdx, *aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAFBYORDINAL_RETURN(this, hrc, 9 /*unhandled exception*/, aOrdinal, *aIdx, *aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIdx=%RU32 *aIdxSub=%RU32 *aValEax=%RU32 *aValEbx=%RU32 *aValEcx=%RU32 *aValEdx=%RU32 hrc=%Rhrc\n", this, "PlatformX86::getCPUIDLeafByOrdinal", !RT_VALID_PTR(aIdx) ? 0 : *aIdx, !RT_VALID_PTR(aIdxSub) ? 0 : *aIdxSub, !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 PlatformX86Wrap::GetCPUIDLeaf(ULONG aIdx,
                                           ULONG aIdxSub,
                                           ULONG *aValEax,
                                           ULONG *aValEbx,
                                           ULONG *aValEcx,
                                           ULONG *aValEdx)
{
    LogRelFlow(("{%p} %s: enter aIdx=%RU32 aIdxSub=%RU32 aValEax=%p aValEbx=%p aValEcx=%p aValEdx=%p\n", this, "PlatformX86::getCPUIDLeaf", aIdx, aIdxSub, 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_PLATFORMX86_GETCPUIDLEAF_ENTER(this, aIdx, aIdxSub);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUIDLeaf(aIdx,
                               aIdxSub,
                               aValEax,
                               aValEbx,
                               aValEcx,
                               aValEdx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAF_RETURN(this, hrc, 0 /*normal*/, aIdx, aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAF_RETURN(this, hrc, 1 /*hrc exception*/, aIdx, aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETCPUIDLEAF_RETURN(this, hrc, 9 /*unhandled exception*/, aIdx, aIdxSub, *aValEax, *aValEbx, *aValEcx, *aValEdx);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValEax=%RU32 *aValEbx=%RU32 *aValEcx=%RU32 *aValEdx=%RU32 hrc=%Rhrc\n", this, "PlatformX86::getCPUIDLeaf", !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 PlatformX86Wrap::SetCPUIDLeaf(ULONG aIdx,
                                           ULONG aIdxSub,
                                           ULONG aValEax,
                                           ULONG aValEbx,
                                           ULONG aValEcx,
                                           ULONG aValEdx)
{
    LogRelFlow(("{%p} %s: enter aIdx=%RU32 aIdxSub=%RU32 aValEax=%RU32 aValEbx=%RU32 aValEcx=%RU32 aValEdx=%RU32\n", this, "PlatformX86::setCPUIDLeaf", aIdx, aIdxSub, 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
    {


        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETCPUIDLEAF_ENTER(this, aIdx, aIdxSub, aValEax, aValEbx, aValEcx, aValEdx);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCPUIDLeaf(aIdx,
                               aIdxSub,
                               aValEax,
                               aValEbx,
                               aValEcx,
                               aValEdx);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETCPUIDLEAF_RETURN(this, hrc, 0 /*normal*/, aIdx, aIdxSub, aValEax, aValEbx, aValEcx, aValEdx);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETCPUIDLEAF_RETURN(this, hrc, 1 /*hrc exception*/, aIdx, aIdxSub, aValEax, aValEbx, aValEcx, aValEdx);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETCPUIDLEAF_RETURN(this, hrc, 9 /*unhandled exception*/, aIdx, aIdxSub, aValEax, aValEbx, aValEcx, aValEdx);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::RemoveCPUIDLeaf(ULONG aIdx,
                                              ULONG aIdxSub)
{
    LogRelFlow(("{%p} %s: enter aIdx=%RU32 aIdxSub=%RU32\n", this, "PlatformX86::removeCPUIDLeaf", aIdx, aIdxSub));

    // Clear 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_PLATFORMX86_REMOVECPUIDLEAF_ENTER(this, aIdx, aIdxSub);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeCPUIDLeaf(aIdx,
                                  aIdxSub);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVECPUIDLEAF_RETURN(this, hrc, 0 /*normal*/, aIdx, aIdxSub);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVECPUIDLEAF_RETURN(this, hrc, 1 /*hrc exception*/, aIdx, aIdxSub);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVECPUIDLEAF_RETURN(this, hrc, 9 /*unhandled exception*/, aIdx, aIdxSub);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::RemoveAllCPUIDLeaves()
{
    LogRelFlow(("{%p} %s: enter\n", this, "PlatformX86::removeAllCPUIDLeaves"));

    // Clear 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_PLATFORMX86_REMOVEALLCPUIDLEAVES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeAllCPUIDLeaves();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVEALLCPUIDLEAVES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVEALLCPUIDLEAVES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_REMOVEALLCPUIDLEAVES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::GetHWVirtExProperty(HWVirtExPropertyType_T aProperty,
                                                  BOOL *aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%p\n", this, "PlatformX86::getHWVirtExProperty", 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_PLATFORMX86_GETHWVIRTEXPROPERTY_ENTER(this, aProperty);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHWVirtExProperty(aProperty,
                                      aValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETHWVIRTEXPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, *aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_GETHWVIRTEXPROPERTY_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_PLATFORMX86_GETHWVIRTEXPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, *aValue != FALSE);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::SetHWVirtExProperty(HWVirtExPropertyType_T aProperty,
                                                  BOOL aValue)
{
    LogRelFlow(("{%p} %s: enter aProperty=%RU32 aValue=%RTbool\n", this, "PlatformX86::setHWVirtExProperty", 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_PLATFORMX86_SETHWVIRTEXPROPERTY_ENTER(this, aProperty, aValue != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHWVirtExProperty(aProperty,
                                      aValue != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETHWVIRTEXPROPERTY_RETURN(this, hrc, 0 /*normal*/, aProperty, aValue != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMX86_SETHWVIRTEXPROPERTY_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_PLATFORMX86_SETHWVIRTEXPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, aProperty, aValue != FALSE);
#endif
    }

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

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod1IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod2IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod3IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod4IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod5IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod6IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod7IPlatformX86()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformX86Wrap::InternalAndReservedMethod8IPlatformX86()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PlatformX86Wrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PlatformX86Wrap, IPlatformX86)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PlatformX86Wrap.cpp"


// ##### BEGINFILE "EmulatedUSBWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IEmulatedUSB.
 *
 * 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_EMULATEDUSB

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

DEFINE_EMPTY_CTOR_DTOR(EmulatedUSBWrap)

//
// IEmulatedUSB properties
//

STDMETHODIMP EmulatedUSBWrap::COMGETTER(Webcams)(ComSafeArrayOut(BSTR, aWebcams))
{
    LogRelFlow(("{%p} %s: enter aWebcams=%p\n", this, "EmulatedUSB::getWebcams", aWebcams));

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

    HRESULT hrc;

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

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

STDMETHODIMP EmulatedUSBWrap::COMGETTER(InternalAndReservedAttribute1IEmulatedUSB)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::COMGETTER(InternalAndReservedAttribute2IEmulatedUSB)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::COMGETTER(InternalAndReservedAttribute3IEmulatedUSB)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::COMGETTER(InternalAndReservedAttribute4IEmulatedUSB)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IEmulatedUSB methods
//

STDMETHODIMP EmulatedUSBWrap::WebcamAttach(IN_BSTR aPath,
                                           IN_BSTR aSettings)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aSettings=%ls\n", this, "EmulatedUSB::webcamAttach", aPath, 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 TmpPath(aPath);
        BSTRInConverter TmpSettings(aSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMATTACH_ENTER(this, TmpPath.str().c_str(), TmpSettings.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = webcamAttach(TmpPath.str(),
                               TmpSettings.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMATTACH_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), TmpSettings.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMATTACH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMATTACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

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

STDMETHODIMP EmulatedUSBWrap::WebcamDetach(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "EmulatedUSB::webcamDetach", 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_EMULATEDUSB_WEBCAMDETACH_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = webcamDetach(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMDETACH_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMDETACH_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EMULATEDUSB_WEBCAMDETACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP EmulatedUSBWrap::InternalAndReservedMethod1IEmulatedUSB()
{
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::InternalAndReservedMethod2IEmulatedUSB()
{
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::InternalAndReservedMethod3IEmulatedUSB()
{
    return E_NOTIMPL;
}

STDMETHODIMP EmulatedUSBWrap::InternalAndReservedMethod4IEmulatedUSB()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(EmulatedUSBWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EmulatedUSBWrap, IEmulatedUSB)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "EmulatedUSBWrap.cpp"


// ##### BEGINFILE "ConsoleWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IConsole.
 *
 * 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_CONSOLE

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

DEFINE_EMPTY_CTOR_DTOR(ConsoleWrap)

//
// IConsole properties
//

STDMETHODIMP ConsoleWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Console::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_CONSOLE_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_CONSOLE_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_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_CONSOLE_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(State)(MachineState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Console::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_CONSOLE_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_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_CONSOLE_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(Guest)(IGuest **aGuest)
{
    LogRelFlow(("{%p} %s: enter aGuest=%p\n", this, "Console::getGuest", aGuest));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuest);
        ComTypeOutConverter<IGuest> TmpGuest(aGuest);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_GUEST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuest(TmpGuest.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_GUEST_RETURN(this, hrc, 0 /*normal*/,(void *)TmpGuest.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_GUEST_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_GUEST_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(Keyboard)(IKeyboard **aKeyboard)
{
    LogRelFlow(("{%p} %s: enter aKeyboard=%p\n", this, "Console::getKeyboard", aKeyboard));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyboard);
        ComTypeOutConverter<IKeyboard> TmpKeyboard(aKeyboard);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_KEYBOARD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyboard(TmpKeyboard.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_KEYBOARD_RETURN(this, hrc, 0 /*normal*/,(void *)TmpKeyboard.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_KEYBOARD_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_KEYBOARD_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(Mouse)(IMouse **aMouse)
{
    LogRelFlow(("{%p} %s: enter aMouse=%p\n", this, "Console::getMouse", aMouse));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMouse);
        ComTypeOutConverter<IMouse> TmpMouse(aMouse);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_MOUSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMouse(TmpMouse.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_MOUSE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMouse.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_MOUSE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_MOUSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(Display)(IDisplay **aDisplay)
{
    LogRelFlow(("{%p} %s: enter aDisplay=%p\n", this, "Console::getDisplay", aDisplay));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDisplay);
        ComTypeOutConverter<IDisplay> TmpDisplay(aDisplay);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DISPLAY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDisplay(TmpDisplay.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DISPLAY_RETURN(this, hrc, 0 /*normal*/,(void *)TmpDisplay.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DISPLAY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DISPLAY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(Debugger)(IMachineDebugger **aDebugger)
{
    LogRelFlow(("{%p} %s: enter aDebugger=%p\n", this, "Console::getDebugger", aDebugger));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDebugger);
        ComTypeOutConverter<IMachineDebugger> TmpDebugger(aDebugger);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DEBUGGER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDebugger(TmpDebugger.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DEBUGGER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpDebugger.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DEBUGGER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_DEBUGGER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(USBDevices)(ComSafeArrayOut(IUSBDevice *, aUSBDevices))
{
    LogRelFlow(("{%p} %s: enter aUSBDevices=%p\n", this, "Console::getUSBDevices", aUSBDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBDevices);
        ArrayComTypeOutConverter<IUSBDevice> TmpUSBDevices(ComSafeArrayOutArg(aUSBDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_USBDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBDevices(TmpUSBDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_USBDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpUSBDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_USBDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_USBDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(RemoteUSBDevices)(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices))
{
    LogRelFlow(("{%p} %s: enter aRemoteUSBDevices=%p\n", this, "Console::getRemoteUSBDevices", aRemoteUSBDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemoteUSBDevices);
        ArrayComTypeOutConverter<IHostUSBDevice> TmpRemoteUSBDevices(ComSafeArrayOutArg(aRemoteUSBDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_REMOTEUSBDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemoteUSBDevices(TmpRemoteUSBDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_REMOTEUSBDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpRemoteUSBDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_REMOTEUSBDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_REMOTEUSBDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
{
    LogRelFlow(("{%p} %s: enter aSharedFolders=%p\n", this, "Console::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_CONSOLE_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_CONSOLE_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_CONSOLE_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_CONSOLE_GET_SHAREDFOLDERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(VRDEServerInfo)(IVRDEServerInfo **aVRDEServerInfo)
{
    LogRelFlow(("{%p} %s: enter aVRDEServerInfo=%p\n", this, "Console::getVRDEServerInfo", aVRDEServerInfo));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEServerInfo);
        ComTypeOutConverter<IVRDEServerInfo> TmpVRDEServerInfo(aVRDEServerInfo);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_VRDESERVERINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEServerInfo(TmpVRDEServerInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_VRDESERVERINFO_RETURN(this, hrc, 0 /*normal*/,(void *)TmpVRDEServerInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_VRDESERVERINFO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_VRDESERVERINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Console::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_CONSOLE_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_CONSOLE_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_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_CONSOLE_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(AttachedPCIDevices)(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachedPCIDevices))
{
    LogRelFlow(("{%p} %s: enter aAttachedPCIDevices=%p\n", this, "Console::getAttachedPCIDevices", aAttachedPCIDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAttachedPCIDevices);
        ArrayComTypeOutConverter<IPCIDeviceAttachment> TmpAttachedPCIDevices(ComSafeArrayOutArg(aAttachedPCIDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_ATTACHEDPCIDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAttachedPCIDevices(TmpAttachedPCIDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_ATTACHEDPCIDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpAttachedPCIDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_ATTACHEDPCIDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_ATTACHEDPCIDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(UseHostClipboard)(BOOL *aUseHostClipboard)
{
    LogRelFlow(("{%p} %s: enter aUseHostClipboard=%p\n", this, "Console::getUseHostClipboard", aUseHostClipboard));

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

    HRESULT hrc;

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

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

STDMETHODIMP ConsoleWrap::COMSETTER(UseHostClipboard)(BOOL aUseHostClipboard)
{
    LogRelFlow(("{%p} %s: enter aUseHostClipboard=%RTbool\n", this, "Console::setUseHostClipboard", aUseHostClipboard));

    // Clear 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_CONSOLE_SET_USEHOSTCLIPBOARD_ENTER(this, aUseHostClipboard != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUseHostClipboard(aUseHostClipboard != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SET_USEHOSTCLIPBOARD_RETURN(this, hrc, 0 /*normal*/,aUseHostClipboard != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SET_USEHOSTCLIPBOARD_RETURN(this, hrc, 1 /*hrc exception*/,aUseHostClipboard != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SET_USEHOSTCLIPBOARD_RETURN(this, hrc, 9 /*unhandled exception*/,aUseHostClipboard != FALSE);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(EmulatedUSB)(IEmulatedUSB **aEmulatedUSB)
{
    LogRelFlow(("{%p} %s: enter aEmulatedUSB=%p\n", this, "Console::getEmulatedUSB", aEmulatedUSB));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEmulatedUSB);
        ComTypeOutConverter<IEmulatedUSB> TmpEmulatedUSB(aEmulatedUSB);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_EMULATEDUSB_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEmulatedUSB(TmpEmulatedUSB.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_EMULATEDUSB_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEmulatedUSB.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_EMULATEDUSB_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GET_EMULATEDUSB_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute1IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute2IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute3IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute4IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute5IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute6IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute7IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::COMGETTER(InternalAndReservedAttribute8IConsole)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IConsole methods
//

STDMETHODIMP ConsoleWrap::PowerUp(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Console::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_CONSOLE_POWERUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerUp(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUP_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::PowerUpPaused(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Console::powerUpPaused", 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_CONSOLE_POWERUPPAUSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerUpPaused(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUPPAUSED_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUPPAUSED_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERUPPAUSED_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::PowerDown(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Console::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_CONSOLE_POWERDOWN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerDown(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERDOWN_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERDOWN_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::Reset()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::reset"));

    // Clear 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_CONSOLE_RESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reset();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESET_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESET_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESET_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::Pause()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::pause"));

    // Clear 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_CONSOLE_PAUSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = pause();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_PAUSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_PAUSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_PAUSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::Resume()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::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_CONSOLE_RESUME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resume();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESUME_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESUME_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_RESUME_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::PowerButton()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::powerButton"));

    // Clear 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_CONSOLE_POWERBUTTON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = powerButton();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERBUTTON_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERBUTTON_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_POWERBUTTON_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::SleepButton()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::sleepButton"));

    // Clear 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_CONSOLE_SLEEPBUTTON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = sleepButton();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SLEEPBUTTON_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SLEEPBUTTON_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_SLEEPBUTTON_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::GetPowerButtonHandled(BOOL *aHandled)
{
    LogRelFlow(("{%p} %s: enter aHandled=%p\n", this, "Console::getPowerButtonHandled", aHandled));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHandled);


        

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

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

STDMETHODIMP ConsoleWrap::GetGuestEnteredACPIMode(BOOL *aEntered)
{
    LogRelFlow(("{%p} %s: enter aEntered=%p\n", this, "Console::getGuestEnteredACPIMode", aEntered));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEntered);


        

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

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

STDMETHODIMP ConsoleWrap::GetDeviceActivity(ComSafeArrayIn(DeviceType_T, aType),
                                            ComSafeArrayOut(DeviceActivity_T, aActivity))
{
    LogRelFlow(("{%p} %s: enter aType=%zu aActivity=%p\n", this, "Console::getDeviceActivity", aType, aActivity));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aActivity);


        ArrayInConverter<DeviceType_T> TmpType(ComSafeArrayInArg(aType));
        ArrayOutConverter<DeviceActivity_T> TmpActivity(ComSafeArrayOutArg(aActivity));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GETDEVICEACTIVITY_ENTER(this, (uint32_t)TmpType.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceActivity(TmpType.array(),
                                    TmpActivity.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GETDEVICEACTIVITY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpType.array().size(), NULL /*for now*/, (uint32_t)TmpActivity.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_GETDEVICEACTIVITY_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_CONSOLE_GETDEVICEACTIVITY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::AttachUSBDevice(IN_BSTR aId,
                                          IN_BSTR aCaptureFilename)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aCaptureFilename=%ls\n", this, "Console::attachUSBDevice", 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_CONSOLE_ATTACHUSBDEVICE_ENTER(this, TmpId.uuid().toStringCurly().c_str(), TmpCaptureFilename.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = attachUSBDevice(TmpId.uuid(),
                                  TmpCaptureFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ATTACHUSBDEVICE_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_CONSOLE_ATTACHUSBDEVICE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ATTACHUSBDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::DetachUSBDevice(IN_BSTR aId,
                                          IUSBDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aDevice=%p\n", this, "Console::detachUSBDevice", aId, 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);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IUSBDevice> TmpDevice(aDevice);

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

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

STDMETHODIMP ConsoleWrap::FindUSBDeviceByAddress(IN_BSTR aName,
                                                 IUSBDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDevice=%p\n", this, "Console::findUSBDeviceByAddress", aName, 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);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IUSBDevice> TmpDevice(aDevice);

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

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

STDMETHODIMP ConsoleWrap::FindUSBDeviceById(IN_BSTR aId,
                                            IUSBDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aDevice=%p\n", this, "Console::findUSBDeviceById", aId, 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);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IUSBDevice> TmpDevice(aDevice);

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

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

STDMETHODIMP ConsoleWrap::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, "Console::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_CONSOLE_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_CONSOLE_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_CONSOLE_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_CONSOLE_CREATESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aWritable != FALSE, aAutomount != FALSE, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::RemoveSharedFolder(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Console::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_CONSOLE_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_CONSOLE_REMOVESHAREDFOLDER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVESHAREDFOLDER_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVESHAREDFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::Teleport(IN_BSTR aHostname,
                                   ULONG aTcpport,
                                   IN_BSTR aPassword,
                                   ULONG aMaxDowntime,
                                   IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aHostname=%ls aTcpport=%RU32 aPassword=%ls aMaxDowntime=%RU32 aProgress=%p\n", this, "Console::teleport", aHostname, aTcpport, aPassword, aMaxDowntime, 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 TmpHostname(aHostname);
        
        BSTRInConverter TmpPassword(aPassword);
        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_TELEPORT_ENTER(this, TmpHostname.str().c_str(), aTcpport, TmpPassword.str().c_str(), aMaxDowntime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = teleport(TmpHostname.str(),
                           aTcpport,
                           TmpPassword.str(),
                           aMaxDowntime,
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_TELEPORT_RETURN(this, hrc, 0 /*normal*/, TmpHostname.str().c_str(), aTcpport, TmpPassword.str().c_str(), aMaxDowntime, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_TELEPORT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aTcpport, 0, aMaxDowntime, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_TELEPORT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aTcpport, 0, aMaxDowntime, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::AddEncryptionPassword(IN_BSTR aId,
                                                IN_BSTR aPassword,
                                                BOOL aClearOnSuspend)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aPassword=%ls aClearOnSuspend=%RTbool\n", this, "Console::addEncryptionPassword", aId, aPassword, aClearOnSuspend));

    // Clear 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_CONSOLE_ADDENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str(), TmpPassword.str().c_str(), aClearOnSuspend != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addEncryptionPassword(TmpId.str(),
                                        TmpPassword.str(),
                                        aClearOnSuspend != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str(), TmpPassword.str().c_str(), aClearOnSuspend != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aClearOnSuspend != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aClearOnSuspend != FALSE);
#endif
    }

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

STDMETHODIMP ConsoleWrap::AddEncryptionPasswords(ComSafeArrayIn(IN_BSTR, aIds),
                                                 ComSafeArrayIn(IN_BSTR, aPasswords),
                                                 BOOL aClearOnSuspend)
{
    LogRelFlow(("{%p} %s: enter aIds=%zu aPasswords=%zu aClearOnSuspend=%RTbool\n", this, "Console::addEncryptionPasswords", aIds, aPasswords, aClearOnSuspend));

    // Clear 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_CONSOLE_ADDENCRYPTIONPASSWORDS_ENTER(this, (uint32_t)TmpIds.array().size(), NULL /*for now*/, (uint32_t)TmpPasswords.array().size(), NULL /*for now*/, aClearOnSuspend != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addEncryptionPasswords(TmpIds.array(),
                                         TmpPasswords.array(),
                                         aClearOnSuspend != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpIds.array().size(), NULL /*for now*/, (uint32_t)TmpPasswords.array().size(), NULL /*for now*/, aClearOnSuspend != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, aClearOnSuspend != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, aClearOnSuspend != FALSE);
#endif
    }

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

STDMETHODIMP ConsoleWrap::RemoveEncryptionPassword(IN_BSTR aId)
{
    LogRelFlow(("{%p} %s: enter aId=%ls\n", this, "Console::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_CONSOLE_REMOVEENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeEncryptionPassword(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::ClearAllEncryptionPasswords()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Console::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_CONSOLE_CLEARALLENCRYPTIONPASSWORDS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = clearAllEncryptionPasswords();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod1IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod2IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod3IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod4IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod5IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod6IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod7IConsole()
{
    return E_NOTIMPL;
}

STDMETHODIMP ConsoleWrap::InternalAndReservedMethod8IConsole()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ConsoleWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ConsoleWrap, IConsole)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ConsoleWrap.cpp"


// ##### BEGINFILE "HostNetworkInterfaceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostNetworkInterface.
 *
 * 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_HOSTNETWORKINTERFACE

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

DEFINE_EMPTY_CTOR_DTOR(HostNetworkInterfaceWrap)

//
// IHostNetworkInterface properties
//

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(ShortName)(BSTR *aShortName)
{
    LogRelFlow(("{%p} %s: enter aShortName=%p\n", this, "HostNetworkInterface::getShortName", aShortName));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShortName);
        BSTROutConverter TmpShortName(aShortName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_SHORTNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShortName(TmpShortName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_SHORTNAME_RETURN(this, hrc, 0 /*normal*/,TmpShortName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_SHORTNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_SHORTNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
    LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NETWORKNAME_RETURN(this, hrc, 0 /*normal*/,TmpNetworkName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NETWORKNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(DHCPEnabled)(BOOL *aDHCPEnabled)
{
    LogRelFlow(("{%p} %s: enter aDHCPEnabled=%p\n", this, "HostNetworkInterface::getDHCPEnabled", aDHCPEnabled));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(IPAddress)(BSTR *aIPAddress)
{
    LogRelFlow(("{%p} %s: enter aIPAddress=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_IPADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpIPAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_IPADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(NetworkMask)(BSTR *aNetworkMask)
{
    LogRelFlow(("{%p} %s: enter aNetworkMask=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NETWORKMASK_RETURN(this, hrc, 0 /*normal*/,TmpNetworkMask.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_NETWORKMASK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(IPV6Supported)(BOOL *aIPV6Supported)
{
    LogRelFlow(("{%p} %s: enter aIPV6Supported=%p\n", this, "HostNetworkInterface::getIPV6Supported", aIPV6Supported));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(IPV6Address)(BSTR *aIPV6Address)
{
    LogRelFlow(("{%p} %s: enter aIPV6Address=%p\n", this, "HostNetworkInterface::getIPV6Address", aIPV6Address));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIPV6Address);
        BSTROutConverter TmpIPV6Address(aIPV6Address);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_IPV6ADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIPV6Address(TmpIPV6Address.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_IPV6ADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpIPV6Address.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_IPV6ADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_IPV6ADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(IPV6NetworkMaskPrefixLength)(ULONG *aIPV6NetworkMaskPrefixLength)
{
    LogRelFlow(("{%p} %s: enter aIPV6NetworkMaskPrefixLength=%p\n", this, "HostNetworkInterface::getIPV6NetworkMaskPrefixLength", aIPV6NetworkMaskPrefixLength));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(HardwareAddress)(BSTR *aHardwareAddress)
{
    LogRelFlow(("{%p} %s: enter aHardwareAddress=%p\n", this, "HostNetworkInterface::getHardwareAddress", aHardwareAddress));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardwareAddress);
        BSTROutConverter TmpHardwareAddress(aHardwareAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_HARDWAREADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardwareAddress(TmpHardwareAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_HARDWAREADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpHardwareAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_HARDWAREADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_HARDWAREADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(MediumType)(HostNetworkInterfaceMediumType_T *aMediumType)
{
    LogRelFlow(("{%p} %s: enter aMediumType=%p\n", this, "HostNetworkInterface::getMediumType", aMediumType));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(Status)(HostNetworkInterfaceStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "HostNetworkInterface::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_HOSTNETWORKINTERFACE_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_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_HOSTNETWORKINTERFACE_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(InterfaceType)(HostNetworkInterfaceType_T *aInterfaceType)
{
    LogRelFlow(("{%p} %s: enter aInterfaceType=%p\n", this, "HostNetworkInterface::getInterfaceType", aInterfaceType));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(Wireless)(BOOL *aWireless)
{
    LogRelFlow(("{%p} %s: enter aWireless=%p\n", this, "HostNetworkInterface::getWireless", aWireless));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(InternalAndReservedAttribute1IHostNetworkInterface)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(InternalAndReservedAttribute2IHostNetworkInterface)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(InternalAndReservedAttribute3IHostNetworkInterface)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostNetworkInterfaceWrap::COMGETTER(InternalAndReservedAttribute4IHostNetworkInterface)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostNetworkInterface methods
//

STDMETHODIMP HostNetworkInterfaceWrap::EnableStaticIPConfig(IN_BSTR aIPAddress,
                                                            IN_BSTR aNetworkMask)
{
    LogRelFlow(("{%p} %s: enter aIPAddress=%ls aNetworkMask=%ls\n", this, "HostNetworkInterface::enableStaticIPConfig", aIPAddress, 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
    {


        BSTRInConverter TmpIPAddress(aIPAddress);
        BSTRInConverter TmpNetworkMask(aNetworkMask);

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

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

STDMETHODIMP HostNetworkInterfaceWrap::EnableStaticIPConfigV6(IN_BSTR aIPV6Address,
                                                              ULONG aIPV6NetworkMaskPrefixLength)
{
    LogRelFlow(("{%p} %s: enter aIPV6Address=%ls aIPV6NetworkMaskPrefixLength=%RU32\n", this, "HostNetworkInterface::enableStaticIPConfigV6", aIPV6Address, aIPV6NetworkMaskPrefixLength));

    // Clear 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 TmpIPV6Address(aIPV6Address);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLESTATICIPCONFIGV6_ENTER(this, TmpIPV6Address.str().c_str(), aIPV6NetworkMaskPrefixLength);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enableStaticIPConfigV6(TmpIPV6Address.str(),
                                         aIPV6NetworkMaskPrefixLength);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLESTATICIPCONFIGV6_RETURN(this, hrc, 0 /*normal*/, TmpIPV6Address.str().c_str(), aIPV6NetworkMaskPrefixLength);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLESTATICIPCONFIGV6_RETURN(this, hrc, 1 /*hrc exception*/, 0, aIPV6NetworkMaskPrefixLength);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLESTATICIPCONFIGV6_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aIPV6NetworkMaskPrefixLength);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::EnableDynamicIPConfig()
{
    LogRelFlow(("{%p} %s: enter\n", this, "HostNetworkInterface::enableDynamicIPConfig"));

    // Clear 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_HOSTNETWORKINTERFACE_ENABLEDYNAMICIPCONFIG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enableDynamicIPConfig();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLEDYNAMICIPCONFIG_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLEDYNAMICIPCONFIG_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_ENABLEDYNAMICIPCONFIG_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::DHCPRediscover()
{
    LogRelFlow(("{%p} %s: enter\n", this, "HostNetworkInterface::DHCPRediscover"));

    // Clear 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_HOSTNETWORKINTERFACE_DHCPREDISCOVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = DHCPRediscover();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_DHCPREDISCOVER_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_DHCPREDISCOVER_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTNETWORKINTERFACE_DHCPREDISCOVER_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP HostNetworkInterfaceWrap::InternalAndReservedMethod1IHostNetworkInterface()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostNetworkInterfaceWrap::InternalAndReservedMethod2IHostNetworkInterface()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostNetworkInterfaceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostNetworkInterfaceWrap, IHostNetworkInterface)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostNetworkInterfaceWrap.cpp"


// ##### BEGINFILE "HostUpdateAgentWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostUpdateAgent.
 *
 * 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_HOSTUPDATEAGENT

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

DEFINE_EMPTY_CTOR_DTOR(HostUpdateAgentWrap)

//
// IUpdateAgent properties
//

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Order)(ULONG *aOrder)
{
    LogRelFlow(("{%p} %s: enter aOrder=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_ORDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOrder(aOrder);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_ORDER_RETURN(this, hrc, 0 /*normal*/,*aOrder);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_ORDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aOrder);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(DependsOn)(ComSafeArrayOut(BSTR, aDependsOn))
{
    LogRelFlow(("{%p} %s: enter aDependsOn=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_DEPENDSON_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(DownloadUrl)(BSTR *aDownloadUrl)
{
    LogRelFlow(("{%p} %s: enter aDownloadUrl=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_DOWNLOADURL_RETURN(this, hrc, 0 /*normal*/,TmpDownloadUrl.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_DOWNLOADURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(WebUrl)(BSTR *aWebUrl)
{
    LogRelFlow(("{%p} %s: enter aWebUrl=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_WEBURL_RETURN(this, hrc, 0 /*normal*/,TmpWebUrl.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_WEBURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(ReleaseNotes)(BSTR *aReleaseNotes)
{
    LogRelFlow(("{%p} %s: enter aReleaseNotes=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_RELEASENOTES_RETURN(this, hrc, 0 /*normal*/,TmpReleaseNotes.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_RELEASENOTES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Hidden)(BOOL *aHidden)
{
    LogRelFlow(("{%p} %s: enter aHidden=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_HIDDEN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHidden(aHidden);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_HIDDEN_RETURN(this, hrc, 0 /*normal*/,*aHidden != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_HIDDEN_RETURN(this, hrc, 9 /*unhandled exception*/,*aHidden != FALSE);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(State)(UpdateState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(CheckFrequency)(ULONG *aCheckFrequency)
{
    LogRelFlow(("{%p} %s: enter aCheckFrequency=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_CHECKFREQUENCY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCheckFrequency(aCheckFrequency);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_CHECKFREQUENCY_RETURN(this, hrc, 0 /*normal*/,*aCheckFrequency);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_CHECKFREQUENCY_RETURN(this, hrc, 9 /*unhandled exception*/,*aCheckFrequency);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMSETTER(CheckFrequency)(ULONG aCheckFrequency)
{
    LogRelFlow(("{%p} %s: enter aCheckFrequency=%RU32\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_CHECKFREQUENCY_RETURN(this, hrc, 0 /*normal*/,aCheckFrequency);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_CHECKFREQUENCY_RETURN(this, hrc, 9 /*unhandled exception*/,aCheckFrequency);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(Channel)(UpdateChannel_T *aChannel)
{
    LogRelFlow(("{%p} %s: enter aChannel=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_CHANNEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChannel(aChannel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_CHANNEL_RETURN(this, hrc, 0 /*normal*/,*aChannel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_CHANNEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aChannel);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMSETTER(Channel)(UpdateChannel_T aChannel)
{
    LogRelFlow(("{%p} %s: enter aChannel=%RU32\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_CHANNEL_RETURN(this, hrc, 0 /*normal*/,aChannel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_CHANNEL_RETURN(this, hrc, 9 /*unhandled exception*/,aChannel);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(RepositoryURL)(BSTR *aRepositoryURL)
{
    LogRelFlow(("{%p} %s: enter aRepositoryURL=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_REPOSITORYURL_RETURN(this, hrc, 0 /*normal*/,TmpRepositoryURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_REPOSITORYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMSETTER(RepositoryURL)(IN_BSTR aRepositoryURL)
{
    LogRelFlow(("{%p} %s: enter aRepositoryURL=%ls\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_REPOSITORYURL_RETURN(this, hrc, 0 /*normal*/,TmpRepositoryURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_SET_REPOSITORYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(LastCheckDate)(BSTR *aLastCheckDate)
{
    LogRelFlow(("{%p} %s: enter aLastCheckDate=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_LASTCHECKDATE_RETURN(this, hrc, 0 /*normal*/,TmpLastCheckDate.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_LASTCHECKDATE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(CheckCount)(ULONG *aCheckCount)
{
    LogRelFlow(("{%p} %s: enter aCheckCount=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_CHECKCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCheckCount(aCheckCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_CHECKCOUNT_RETURN(this, hrc, 0 /*normal*/,*aCheckCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_CHECKCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCheckCount);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(IsCheckNeeded)(BOOL *aIsCheckNeeded)
{
    LogRelFlow(("{%p} %s: enter aIsCheckNeeded=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_GET_ISCHECKNEEDED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCheckNeeded(aIsCheckNeeded);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_GET_ISCHECKNEEDED_RETURN(this, hrc, 0 /*normal*/,*aIsCheckNeeded != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_ISCHECKNEEDED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCheckNeeded != FALSE);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(SupportedChannels)(ComSafeArrayOut(UpdateChannel_T, aSupportedChannels))
{
    LogRelFlow(("{%p} %s: enter aSupportedChannels=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_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_HOSTUPDATEAGENT_GET_SUPPORTEDCHANNELS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute1IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute2IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute3IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute4IUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IHostUpdateAgent properties
//

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "HostUpdateAgent::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, "HostUpdateAgent::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute1IHostUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute2IHostUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute3IHostUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::COMGETTER(InternalAndReservedAttribute4IHostUpdateAgent)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUpdateAgent methods
//

STDMETHODIMP HostUpdateAgentWrap::CheckFor(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_CHECKFOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkFor(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_CHECKFOR_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_CHECKFOR_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_CHECKFOR_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::Download(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_DOWNLOAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = download(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_DOWNLOAD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::Install(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_INSTALL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = install(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_INSTALL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_INSTALL_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_INSTALL_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::Rollback()
{
    LogRelFlow(("{%p} %s: enter\n", this, "HostUpdateAgent::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_HOSTUPDATEAGENT_ROLLBACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = rollback();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_ROLLBACK_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_ROLLBACK_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTUPDATEAGENT_ROLLBACK_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

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

STDMETHODIMP HostUpdateAgentWrap::InternalAndReservedMethod1IUpdateAgent()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::InternalAndReservedMethod2IUpdateAgent()
{
    return E_NOTIMPL;
}

//
// IHostUpdateAgent methods
//

STDMETHODIMP HostUpdateAgentWrap::InternalAndReservedMethod1IHostUpdateAgent()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateAgentWrap::InternalAndReservedMethod2IHostUpdateAgent()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostUpdateAgentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HostUpdateAgentWrap, IHostUpdateAgent, IUpdateAgent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostUpdateAgentWrap.cpp"


// ##### BEGINFILE "HostDriveWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostDrive.
 *
 * 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_HOSTDRIVE

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

DEFINE_EMPTY_CTOR_DTOR(HostDriveWrap)

//
// IHostDrive properties
//

STDMETHODIMP HostDriveWrap::COMGETTER(DrivePath)(BSTR *aDrivePath)
{
    LogRelFlow(("{%p} %s: enter aDrivePath=%p\n", this, "HostDrive::getDrivePath", aDrivePath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDrivePath);
        BSTROutConverter TmpDrivePath(aDrivePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_DRIVEPATH_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDrivePath(TmpDrivePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_DRIVEPATH_RETURN(this, hrc, 0 /*normal*/,TmpDrivePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_DRIVEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_DRIVEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostDriveWrap::COMGETTER(PartitioningType)(PartitioningType_T *aPartitioningType)
{
    LogRelFlow(("{%p} %s: enter aPartitioningType=%p\n", this, "HostDrive::getPartitioningType", aPartitioningType));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostDriveWrap::COMGETTER(Uuid)(BSTR *aUuid)
{
    LogRelFlow(("{%p} %s: enter aUuid=%p\n", this, "HostDrive::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_HOSTDRIVE_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_HOSTDRIVE_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_HOSTDRIVE_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_HOSTDRIVE_GET_UUID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostDriveWrap::COMGETTER(SectorSize)(ULONG *aSectorSize)
{
    LogRelFlow(("{%p} %s: enter aSectorSize=%p\n", this, "HostDrive::getSectorSize", aSectorSize));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostDriveWrap::COMGETTER(Size)(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%p\n", this, "HostDrive::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_HOSTDRIVE_GET_SIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_SIZE_RETURN(this, hrc, 0 /*normal*/,*aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_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_HOSTDRIVE_GET_SIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSize);
#endif
    }

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

STDMETHODIMP HostDriveWrap::COMGETTER(Model)(BSTR *aModel)
{
    LogRelFlow(("{%p} %s: enter aModel=%p\n", this, "HostDrive::getModel", aModel));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aModel);
        BSTROutConverter TmpModel(aModel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_MODEL_ENTER(this);
#endif
        AutoLimitedCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getModel(TmpModel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_MODEL_RETURN(this, hrc, 0 /*normal*/,TmpModel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_MODEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_MODEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostDriveWrap::COMGETTER(Partitions)(ComSafeArrayOut(IHostDrivePartition *, aPartitions))
{
    LogRelFlow(("{%p} %s: enter aPartitions=%p\n", this, "HostDrive::getPartitions", aPartitions));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPartitions);
        ArrayComTypeOutConverter<IHostDrivePartition> TmpPartitions(ComSafeArrayOutArg(aPartitions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_PARTITIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPartitions(TmpPartitions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_PARTITIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPartitions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_PARTITIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTDRIVE_GET_PARTITIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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


//
// IHostDrive methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostDriveWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostDriveWrap, IHostDrive)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostDriveWrap.cpp"


// ##### BEGINFILE "HostWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHost.
 *
 * 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_HOST

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

DEFINE_EMPTY_CTOR_DTOR(HostWrap)

//
// IHost properties
//

STDMETHODIMP HostWrap::COMGETTER(Architecture)(PlatformArchitecture_T *aArchitecture)
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%p\n", this, "Host::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_HOST_GET_ARCHITECTURE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getArchitecture(aArchitecture);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_ARCHITECTURE_RETURN(this, hrc, 0 /*normal*/,*aArchitecture);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_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_HOST_GET_ARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/,*aArchitecture);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(X86)(IHostX86 **aX86)
{
    LogRelFlow(("{%p} %s: enter aX86=%p\n", this, "Host::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<IHostX86> TmpX86(aX86);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_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_HOST_GET_X86_RETURN(this, hrc, 0 /*normal*/,(void *)TmpX86.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_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_HOST_GET_X86_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(DVDDrives)(ComSafeArrayOut(IMedium *, aDVDDrives))
{
    LogRelFlow(("{%p} %s: enter aDVDDrives=%p\n", this, "Host::getDVDDrives", aDVDDrives));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(FloppyDrives)(ComSafeArrayOut(IMedium *, aFloppyDrives))
{
    LogRelFlow(("{%p} %s: enter aFloppyDrives=%p\n", this, "Host::getFloppyDrives", aFloppyDrives));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(AudioDevices)(ComSafeArrayOut(IHostAudioDevice *, aAudioDevices))
{
    LogRelFlow(("{%p} %s: enter aAudioDevices=%p\n", this, "Host::getAudioDevices", aAudioDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAudioDevices);
        ArrayComTypeOutConverter<IHostAudioDevice> TmpAudioDevices(ComSafeArrayOutArg(aAudioDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_AUDIODEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAudioDevices(TmpAudioDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_AUDIODEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpAudioDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_AUDIODEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_AUDIODEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(USBDevices)(ComSafeArrayOut(IHostUSBDevice *, aUSBDevices))
{
    LogRelFlow(("{%p} %s: enter aUSBDevices=%p\n", this, "Host::getUSBDevices", aUSBDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBDevices);
        ArrayComTypeOutConverter<IHostUSBDevice> TmpUSBDevices(ComSafeArrayOutArg(aUSBDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBDevices(TmpUSBDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpUSBDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(USBDeviceFilters)(ComSafeArrayOut(IHostUSBDeviceFilter *, aUSBDeviceFilters))
{
    LogRelFlow(("{%p} %s: enter aUSBDeviceFilters=%p\n", this, "Host::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);
        ArrayComTypeOutConverter<IHostUSBDeviceFilter> TmpUSBDeviceFilters(ComSafeArrayOutArg(aUSBDeviceFilters));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICEFILTERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBDeviceFilters(TmpUSBDeviceFilters.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICEFILTERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpUSBDeviceFilters.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICEFILTERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_USBDEVICEFILTERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(NetworkInterfaces)(ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces))
{
    LogRelFlow(("{%p} %s: enter aNetworkInterfaces=%p\n", this, "Host::getNetworkInterfaces", aNetworkInterfaces));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkInterfaces);
        ArrayComTypeOutConverter<IHostNetworkInterface> TmpNetworkInterfaces(ComSafeArrayOutArg(aNetworkInterfaces));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_NETWORKINTERFACES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkInterfaces(TmpNetworkInterfaces.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_NETWORKINTERFACES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpNetworkInterfaces.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_NETWORKINTERFACES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_NETWORKINTERFACES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(NameServers)(ComSafeArrayOut(BSTR, aNameServers))
{
    LogRelFlow(("{%p} %s: enter aNameServers=%p\n", this, "Host::getNameServers", aNameServers));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(DomainName)(BSTR *aDomainName)
{
    LogRelFlow(("{%p} %s: enter aDomainName=%p\n", this, "Host::getDomainName", aDomainName));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDomainName);
        BSTROutConverter TmpDomainName(aDomainName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_DOMAINNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDomainName(TmpDomainName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_DOMAINNAME_RETURN(this, hrc, 0 /*normal*/,TmpDomainName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_DOMAINNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_DOMAINNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(SearchStrings)(ComSafeArrayOut(BSTR, aSearchStrings))
{
    LogRelFlow(("{%p} %s: enter aSearchStrings=%p\n", this, "Host::getSearchStrings", aSearchStrings));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(ProcessorCount)(ULONG *aProcessorCount)
{
    LogRelFlow(("{%p} %s: enter aProcessorCount=%p\n", this, "Host::getProcessorCount", aProcessorCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(ProcessorOnlineCount)(ULONG *aProcessorOnlineCount)
{
    LogRelFlow(("{%p} %s: enter aProcessorOnlineCount=%p\n", this, "Host::getProcessorOnlineCount", aProcessorOnlineCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(ProcessorCoreCount)(ULONG *aProcessorCoreCount)
{
    LogRelFlow(("{%p} %s: enter aProcessorCoreCount=%p\n", this, "Host::getProcessorCoreCount", aProcessorCoreCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(ProcessorOnlineCoreCount)(ULONG *aProcessorOnlineCoreCount)
{
    LogRelFlow(("{%p} %s: enter aProcessorOnlineCoreCount=%p\n", this, "Host::getProcessorOnlineCoreCount", aProcessorOnlineCoreCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(HostDrives)(ComSafeArrayOut(IHostDrive *, aHostDrives))
{
    LogRelFlow(("{%p} %s: enter aHostDrives=%p\n", this, "Host::getHostDrives", aHostDrives));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostDrives);
        ArrayComTypeOutConverter<IHostDrive> TmpHostDrives(ComSafeArrayOutArg(aHostDrives));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_HOSTDRIVES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostDrives(TmpHostDrives.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_HOSTDRIVES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpHostDrives.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_HOSTDRIVES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_HOSTDRIVES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(MemorySize)(ULONG *aMemorySize)
{
    LogRelFlow(("{%p} %s: enter aMemorySize=%p\n", this, "Host::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_HOST_GET_MEMORYSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMemorySize(aMemorySize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_MEMORYSIZE_RETURN(this, hrc, 0 /*normal*/,*aMemorySize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_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_HOST_GET_MEMORYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMemorySize);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(MemoryAvailable)(ULONG *aMemoryAvailable)
{
    LogRelFlow(("{%p} %s: enter aMemoryAvailable=%p\n", this, "Host::getMemoryAvailable", aMemoryAvailable));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(OperatingSystem)(BSTR *aOperatingSystem)
{
    LogRelFlow(("{%p} %s: enter aOperatingSystem=%p\n", this, "Host::getOperatingSystem", aOperatingSystem));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperatingSystem);
        BSTROutConverter TmpOperatingSystem(aOperatingSystem);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_OPERATINGSYSTEM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperatingSystem(TmpOperatingSystem.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_OPERATINGSYSTEM_RETURN(this, hrc, 0 /*normal*/,TmpOperatingSystem.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_OPERATINGSYSTEM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_OPERATINGSYSTEM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(OSVersion)(BSTR *aOSVersion)
{
    LogRelFlow(("{%p} %s: enter aOSVersion=%p\n", this, "Host::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_HOST_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_HOST_GET_OSVERSION_RETURN(this, hrc, 0 /*normal*/,TmpOSVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_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_HOST_GET_OSVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(UTCTime)(LONG64 *aUTCTime)
{
    LogRelFlow(("{%p} %s: enter aUTCTime=%p\n", this, "Host::getUTCTime", aUTCTime));

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

    HRESULT hrc;

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

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

STDMETHODIMP HostWrap::COMGETTER(VideoInputDevices)(ComSafeArrayOut(IHostVideoInputDevice *, aVideoInputDevices))
{
    LogRelFlow(("{%p} %s: enter aVideoInputDevices=%p\n", this, "Host::getVideoInputDevices", aVideoInputDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVideoInputDevices);
        ArrayComTypeOutConverter<IHostVideoInputDevice> TmpVideoInputDevices(ComSafeArrayOutArg(aVideoInputDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_VIDEOINPUTDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVideoInputDevices(TmpVideoInputDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_VIDEOINPUTDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpVideoInputDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_VIDEOINPUTDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_VIDEOINPUTDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(UpdateHost)(IUpdateAgent **aUpdateHost)
{
    LogRelFlow(("{%p} %s: enter aUpdateHost=%p\n", this, "Host::getUpdateHost", aUpdateHost));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUpdateHost);
        ComTypeOutConverter<IUpdateAgent> TmpUpdateHost(aUpdateHost);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEHOST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUpdateHost(TmpUpdateHost.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEHOST_RETURN(this, hrc, 0 /*normal*/,(void *)TmpUpdateHost.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEHOST_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEHOST_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(UpdateExtPack)(IUpdateAgent **aUpdateExtPack)
{
    LogRelFlow(("{%p} %s: enter aUpdateExtPack=%p\n", this, "Host::getUpdateExtPack", aUpdateExtPack));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUpdateExtPack);
        ComTypeOutConverter<IUpdateAgent> TmpUpdateExtPack(aUpdateExtPack);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEEXTPACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUpdateExtPack(TmpUpdateExtPack.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEEXTPACK_RETURN(this, hrc, 0 /*normal*/,(void *)TmpUpdateExtPack.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(UpdateGuestAdditions)(IUpdateAgent **aUpdateGuestAdditions)
{
    LogRelFlow(("{%p} %s: enter aUpdateGuestAdditions=%p\n", this, "Host::getUpdateGuestAdditions", aUpdateGuestAdditions));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUpdateGuestAdditions);
        ComTypeOutConverter<IUpdateAgent> TmpUpdateGuestAdditions(aUpdateGuestAdditions);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEGUESTADDITIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUpdateGuestAdditions(TmpUpdateGuestAdditions.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEGUESTADDITIONS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpUpdateGuestAdditions.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEGUESTADDITIONS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GET_UPDATEGUESTADDITIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute1IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute2IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute3IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute4IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute5IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute6IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute7IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute8IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute9IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute10IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute11IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::COMGETTER(InternalAndReservedAttribute12IHost)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHost methods
//

STDMETHODIMP HostWrap::GetProcessorSpeed(ULONG aCpuId,
                                         ULONG *aSpeed)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aSpeed=%p\n", this, "Host::getProcessorSpeed", aCpuId, 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_HOST_GETPROCESSORSPEED_ENTER(this, aCpuId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessorSpeed(aCpuId,
                                    aSpeed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORSPEED_RETURN(this, hrc, 0 /*normal*/, aCpuId, *aSpeed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORSPEED_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, *aSpeed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORSPEED_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, *aSpeed);
#endif
    }

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

STDMETHODIMP HostWrap::GetProcessorFeature(ProcessorFeature_T aFeature,
                                           BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFeature=%RU32 aSupported=%p\n", this, "Host::getProcessorFeature", aFeature, 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_HOST_GETPROCESSORFEATURE_ENTER(this, aFeature);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessorFeature(aFeature,
                                      aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORFEATURE_RETURN(this, hrc, 0 /*normal*/, aFeature, *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORFEATURE_RETURN(this, hrc, 1 /*hrc exception*/, aFeature, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORFEATURE_RETURN(this, hrc, 9 /*unhandled exception*/, aFeature, *aSupported != FALSE);
#endif
    }

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

STDMETHODIMP HostWrap::GetProcessorDescription(ULONG aCpuId,
                                               BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aCpuId=%RU32 aDescription=%p\n", this, "Host::getProcessorDescription", aCpuId, 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_HOST_GETPROCESSORDESCRIPTION_ENTER(this, aCpuId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessorDescription(aCpuId,
                                          TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, aCpuId, TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, aCpuId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GETPROCESSORDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuId, 0);
#endif
    }

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

STDMETHODIMP HostWrap::CreateHostOnlyNetworkInterface(IHostNetworkInterface **aHostInterface,
                                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aHostInterface=%p aProgress=%p\n", this, "Host::createHostOnlyNetworkInterface", aHostInterface, 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(aHostInterface);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IHostNetworkInterface> TmpHostInterface(aHostInterface);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

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

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

STDMETHODIMP HostWrap::RemoveHostOnlyNetworkInterface(IN_BSTR aId,
                                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aProgress=%p\n", this, "Host::removeHostOnlyNetworkInterface", 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_HOST_REMOVEHOSTONLYNETWORKINTERFACE_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeHostOnlyNetworkInterface(TmpId.uuid(),
                                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEHOSTONLYNETWORKINTERFACE_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_HOST_REMOVEHOSTONLYNETWORKINTERFACE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEHOSTONLYNETWORKINTERFACE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::CreateUSBDeviceFilter(IN_BSTR aName,
                                             IHostUSBDeviceFilter **aFilter)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aFilter=%p\n", this, "Host::createUSBDeviceFilter", aName, 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);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IHostUSBDeviceFilter> TmpFilter(aFilter);

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

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

STDMETHODIMP HostWrap::InsertUSBDeviceFilter(ULONG aPosition,
                                             IHostUSBDeviceFilter *aFilter)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32 aFilter=%p\n", this, "Host::insertUSBDeviceFilter", aPosition, 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
    {


        
        ComTypeInConverter<IHostUSBDeviceFilter> TmpFilter(aFilter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_INSERTUSBDEVICEFILTER_ENTER(this, aPosition, (void *)TmpFilter.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = insertUSBDeviceFilter(aPosition,
                                        TmpFilter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_INSERTUSBDEVICEFILTER_RETURN(this, hrc, 0 /*normal*/, aPosition, (void *)TmpFilter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_INSERTUSBDEVICEFILTER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_INSERTUSBDEVICEFILTER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition, 0);
#endif
    }

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

STDMETHODIMP HostWrap::RemoveUSBDeviceFilter(ULONG aPosition)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32\n", this, "Host::removeUSBDeviceFilter", aPosition));

    // Clear 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_HOST_REMOVEUSBDEVICEFILTER_ENTER(this, aPosition);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeUSBDeviceFilter(aPosition);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICEFILTER_RETURN(this, hrc, 0 /*normal*/, aPosition);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICEFILTER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICEFILTER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition);
#endif
    }

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

STDMETHODIMP HostWrap::FindHostDVDDrive(IN_BSTR aName,
                                        IMedium **aDrive)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDrive=%p\n", this, "Host::findHostDVDDrive", aName, aDrive));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDrive);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IMedium> TmpDrive(aDrive);

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

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

STDMETHODIMP HostWrap::FindHostFloppyDrive(IN_BSTR aName,
                                           IMedium **aDrive)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDrive=%p\n", this, "Host::findHostFloppyDrive", aName, aDrive));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDrive);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IMedium> TmpDrive(aDrive);

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

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

STDMETHODIMP HostWrap::FindHostNetworkInterfaceByName(IN_BSTR aName,
                                                      IHostNetworkInterface **aNetworkInterface)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aNetworkInterface=%p\n", this, "Host::findHostNetworkInterfaceByName", aName, aNetworkInterface));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkInterface);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IHostNetworkInterface> TmpNetworkInterface(aNetworkInterface);

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

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

STDMETHODIMP HostWrap::FindHostNetworkInterfaceById(IN_BSTR aId,
                                                    IHostNetworkInterface **aNetworkInterface)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aNetworkInterface=%p\n", this, "Host::findHostNetworkInterfaceById", aId, aNetworkInterface));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkInterface);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IHostNetworkInterface> TmpNetworkInterface(aNetworkInterface);

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

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

STDMETHODIMP HostWrap::FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
                                                       ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces))
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aNetworkInterfaces=%p\n", this, "Host::findHostNetworkInterfacesOfType", aType, aNetworkInterfaces));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetworkInterfaces);


        
        ArrayComTypeOutConverter<IHostNetworkInterface> TmpNetworkInterfaces(ComSafeArrayOutArg(aNetworkInterfaces));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_FINDHOSTNETWORKINTERFACESOFTYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findHostNetworkInterfacesOfType(aType,
                                                  TmpNetworkInterfaces.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_FINDHOSTNETWORKINTERFACESOFTYPE_RETURN(this, hrc, 0 /*normal*/, aType, (uint32_t)TmpNetworkInterfaces.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_FINDHOSTNETWORKINTERFACESOFTYPE_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_HOST_FINDHOSTNETWORKINTERFACESOFTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::FindUSBDeviceById(IN_BSTR aId,
                                         IHostUSBDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aDevice=%p\n", this, "Host::findUSBDeviceById", aId, 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);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<IHostUSBDevice> TmpDevice(aDevice);

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

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

STDMETHODIMP HostWrap::FindUSBDeviceByAddress(IN_BSTR aName,
                                              IHostUSBDevice **aDevice)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDevice=%p\n", this, "Host::findUSBDeviceByAddress", aName, 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);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IHostUSBDevice> TmpDevice(aDevice);

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

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

STDMETHODIMP HostWrap::GenerateMACAddress(BSTR *aAddress)
{
    LogRelFlow(("{%p} %s: enter aAddress=%p\n", this, "Host::generateMACAddress", 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_HOST_GENERATEMACADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = generateMACAddress(TmpAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GENERATEMACADDRESS_RETURN(this, hrc, 0 /*normal*/, TmpAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GENERATEMACADDRESS_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_GENERATEMACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP HostWrap::AddUSBDeviceSource(IN_BSTR aBackend,
                                          IN_BSTR aId,
                                          IN_BSTR aAddress,
                                          ComSafeArrayIn(IN_BSTR, aPropertyNames),
                                          ComSafeArrayIn(IN_BSTR, aPropertyValues))
{
    LogRelFlow(("{%p} %s: enter aBackend=%ls aId=%ls aAddress=%ls aPropertyNames=%zu aPropertyValues=%zu\n", this, "Host::addUSBDeviceSource", aBackend, aId, aAddress, aPropertyNames, aPropertyValues));

    // Clear 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 TmpBackend(aBackend);
        BSTRInConverter TmpId(aId);
        BSTRInConverter TmpAddress(aAddress);
        ArrayBSTRInConverter TmpPropertyNames(ComSafeArrayInArg(aPropertyNames));
        ArrayBSTRInConverter TmpPropertyValues(ComSafeArrayInArg(aPropertyValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ADDUSBDEVICESOURCE_ENTER(this, TmpBackend.str().c_str(), TmpId.str().c_str(), TmpAddress.str().c_str(), (uint32_t)TmpPropertyNames.array().size(), NULL /*for now*/, (uint32_t)TmpPropertyValues.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addUSBDeviceSource(TmpBackend.str(),
                                     TmpId.str(),
                                     TmpAddress.str(),
                                     TmpPropertyNames.array(),
                                     TmpPropertyValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ADDUSBDEVICESOURCE_RETURN(this, hrc, 0 /*normal*/, TmpBackend.str().c_str(), TmpId.str().c_str(), TmpAddress.str().c_str(), (uint32_t)TmpPropertyNames.array().size(), NULL /*for now*/, (uint32_t)TmpPropertyValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ADDUSBDEVICESOURCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ADDUSBDEVICESOURCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP HostWrap::RemoveUSBDeviceSource(IN_BSTR aId)
{
    LogRelFlow(("{%p} %s: enter aId=%ls\n", this, "Host::removeUSBDeviceSource", 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_HOST_REMOVEUSBDEVICESOURCE_ENTER(this, TmpId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeUSBDeviceSource(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICESOURCE_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICESOURCE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_REMOVEUSBDEVICESOURCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP HostWrap::IsExecutionEngineSupported(CPUArchitecture_T aCpuArchitecture,
                                                  VMExecutionEngine_T aExecutionEngine,
                                                  BOOL *aIsSupported)
{
    LogRelFlow(("{%p} %s: enter aCpuArchitecture=%RU32 aExecutionEngine=%RU32 aIsSupported=%p\n", this, "Host::isExecutionEngineSupported", aCpuArchitecture, aExecutionEngine, aIsSupported));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsSupported);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ISEXECUTIONENGINESUPPORTED_ENTER(this, aCpuArchitecture, aExecutionEngine);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isExecutionEngineSupported(aCpuArchitecture,
                                             aExecutionEngine,
                                             aIsSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ISEXECUTIONENGINESUPPORTED_RETURN(this, hrc, 0 /*normal*/, aCpuArchitecture, aExecutionEngine, *aIsSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ISEXECUTIONENGINESUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, aCpuArchitecture, aExecutionEngine, *aIsSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOST_ISEXECUTIONENGINESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuArchitecture, aExecutionEngine, *aIsSupported != FALSE);
#endif
    }

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

STDMETHODIMP HostWrap::InternalAndReservedMethod1IHost()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::InternalAndReservedMethod2IHost()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::InternalAndReservedMethod3IHost()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::InternalAndReservedMethod4IHost()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::InternalAndReservedMethod5IHost()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostWrap::InternalAndReservedMethod6IHost()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostWrap, IHost)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostWrap.cpp"


// ##### BEGINFILE "PlatformPropertiesWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPlatformProperties.
 *
 * 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_PLATFORMPROPERTIES

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

DEFINE_EMPTY_CTOR_DTOR(PlatformPropertiesWrap)

//
// IPlatformProperties properties
//

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(RawModeSupported)(BOOL *aRawModeSupported)
{
    LogRelFlow(("{%p} %s: enter aRawModeSupported=%p\n", this, "PlatformProperties::getRawModeSupported", aRawModeSupported));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(ExclusiveHwVirt)(BOOL *aExclusiveHwVirt)
{
    LogRelFlow(("{%p} %s: enter aExclusiveHwVirt=%p\n", this, "PlatformProperties::getExclusiveHwVirt", aExclusiveHwVirt));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMSETTER(ExclusiveHwVirt)(BOOL aExclusiveHwVirt)
{
    LogRelFlow(("{%p} %s: enter aExclusiveHwVirt=%RTbool\n", this, "PlatformProperties::setExclusiveHwVirt", aExclusiveHwVirt));

    // Clear 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_PLATFORMPROPERTIES_SET_EXCLUSIVEHWVIRT_ENTER(this, aExclusiveHwVirt != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setExclusiveHwVirt(aExclusiveHwVirt != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_SET_EXCLUSIVEHWVIRT_RETURN(this, hrc, 0 /*normal*/,aExclusiveHwVirt != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_SET_EXCLUSIVEHWVIRT_RETURN(this, hrc, 1 /*hrc exception*/,aExclusiveHwVirt != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_SET_EXCLUSIVEHWVIRT_RETURN(this, hrc, 9 /*unhandled exception*/,aExclusiveHwVirt != FALSE);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SerialPortCount)(ULONG *aSerialPortCount)
{
    LogRelFlow(("{%p} %s: enter aSerialPortCount=%p\n", this, "PlatformProperties::getSerialPortCount", aSerialPortCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(ParallelPortCount)(ULONG *aParallelPortCount)
{
    LogRelFlow(("{%p} %s: enter aParallelPortCount=%p\n", this, "PlatformProperties::getParallelPortCount", aParallelPortCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(MaxBootPosition)(ULONG *aMaxBootPosition)
{
    LogRelFlow(("{%p} %s: enter aMaxBootPosition=%p\n", this, "PlatformProperties::getMaxBootPosition", aMaxBootPosition));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedParavirtProviders)(ComSafeArrayOut(ParavirtProvider_T, aSupportedParavirtProviders))
{
    LogRelFlow(("{%p} %s: enter aSupportedParavirtProviders=%p\n", this, "PlatformProperties::getSupportedParavirtProviders", aSupportedParavirtProviders));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedParavirtProviders);
        ArrayOutConverter<ParavirtProvider_T> TmpSupportedParavirtProviders(ComSafeArrayOutArg(aSupportedParavirtProviders));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDPARAVIRTPROVIDERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedParavirtProviders(TmpSupportedParavirtProviders.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDPARAVIRTPROVIDERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedParavirtProviders.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDPARAVIRTPROVIDERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDPARAVIRTPROVIDERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedFirmwareTypes)(ComSafeArrayOut(FirmwareType_T, aSupportedFirmwareTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedFirmwareTypes=%p\n", this, "PlatformProperties::getSupportedFirmwareTypes", aSupportedFirmwareTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedFirmwareTypes);
        ArrayOutConverter<FirmwareType_T> TmpSupportedFirmwareTypes(ComSafeArrayOutArg(aSupportedFirmwareTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDFIRMWARETYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedFirmwareTypes(TmpSupportedFirmwareTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDFIRMWARETYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedFirmwareTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDFIRMWARETYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDFIRMWARETYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedGuestOSTypes)(ComSafeArrayOut(IGuestOSType *, aSupportedGuestOSTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedGuestOSTypes=%p\n", this, "PlatformProperties::getSupportedGuestOSTypes", aSupportedGuestOSTypes));

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

    HRESULT hrc;

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

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedGfxControllerTypes)(ComSafeArrayOut(GraphicsControllerType_T, aSupportedGfxControllerTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedGfxControllerTypes=%p\n", this, "PlatformProperties::getSupportedGfxControllerTypes", aSupportedGfxControllerTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedGfxControllerTypes);
        ArrayOutConverter<GraphicsControllerType_T> TmpSupportedGfxControllerTypes(ComSafeArrayOutArg(aSupportedGfxControllerTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDGFXCONTROLLERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedGfxControllerTypes(TmpSupportedGfxControllerTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDGFXCONTROLLERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedGfxControllerTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDGFXCONTROLLERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDGFXCONTROLLERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedNetAdpPromiscModePols)(ComSafeArrayOut(NetworkAdapterPromiscModePolicy_T, aSupportedNetAdpPromiscModePols))
{
    LogRelFlow(("{%p} %s: enter aSupportedNetAdpPromiscModePols=%p\n", this, "PlatformProperties::getSupportedNetAdpPromiscModePols", aSupportedNetAdpPromiscModePols));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedNetAdpPromiscModePols);
        ArrayOutConverter<NetworkAdapterPromiscModePolicy_T> TmpSupportedNetAdpPromiscModePols(ComSafeArrayOutArg(aSupportedNetAdpPromiscModePols));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETADPPROMISCMODEPOLS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedNetAdpPromiscModePols(TmpSupportedNetAdpPromiscModePols.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETADPPROMISCMODEPOLS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedNetAdpPromiscModePols.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETADPPROMISCMODEPOLS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETADPPROMISCMODEPOLS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedNetworkAdapterTypes)(ComSafeArrayOut(NetworkAdapterType_T, aSupportedNetworkAdapterTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedNetworkAdapterTypes=%p\n", this, "PlatformProperties::getSupportedNetworkAdapterTypes", aSupportedNetworkAdapterTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedNetworkAdapterTypes);
        ArrayOutConverter<NetworkAdapterType_T> TmpSupportedNetworkAdapterTypes(ComSafeArrayOutArg(aSupportedNetworkAdapterTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETWORKADAPTERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedNetworkAdapterTypes(TmpSupportedNetworkAdapterTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETWORKADAPTERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedNetworkAdapterTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETWORKADAPTERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDNETWORKADAPTERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedUartTypes)(ComSafeArrayOut(UartType_T, aSupportedUartTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedUartTypes=%p\n", this, "PlatformProperties::getSupportedUartTypes", aSupportedUartTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedUartTypes);
        ArrayOutConverter<UartType_T> TmpSupportedUartTypes(ComSafeArrayOutArg(aSupportedUartTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUARTTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedUartTypes(TmpSupportedUartTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUARTTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedUartTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUARTTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUARTTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedUSBControllerTypes)(ComSafeArrayOut(USBControllerType_T, aSupportedUSBControllerTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedUSBControllerTypes=%p\n", this, "PlatformProperties::getSupportedUSBControllerTypes", aSupportedUSBControllerTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedUSBControllerTypes);
        ArrayOutConverter<USBControllerType_T> TmpSupportedUSBControllerTypes(ComSafeArrayOutArg(aSupportedUSBControllerTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUSBCONTROLLERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedUSBControllerTypes(TmpSupportedUSBControllerTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUSBCONTROLLERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedUSBControllerTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUSBCONTROLLERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDUSBCONTROLLERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedAudioControllerTypes)(ComSafeArrayOut(AudioControllerType_T, aSupportedAudioControllerTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedAudioControllerTypes=%p\n", this, "PlatformProperties::getSupportedAudioControllerTypes", aSupportedAudioControllerTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedAudioControllerTypes);
        ArrayOutConverter<AudioControllerType_T> TmpSupportedAudioControllerTypes(ComSafeArrayOutArg(aSupportedAudioControllerTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDAUDIOCONTROLLERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedAudioControllerTypes(TmpSupportedAudioControllerTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDAUDIOCONTROLLERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedAudioControllerTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDAUDIOCONTROLLERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDAUDIOCONTROLLERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedBootDevices)(ComSafeArrayOut(DeviceType_T, aSupportedBootDevices))
{
    LogRelFlow(("{%p} %s: enter aSupportedBootDevices=%p\n", this, "PlatformProperties::getSupportedBootDevices", aSupportedBootDevices));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedBootDevices);
        ArrayOutConverter<DeviceType_T> TmpSupportedBootDevices(ComSafeArrayOutArg(aSupportedBootDevices));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDBOOTDEVICES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedBootDevices(TmpSupportedBootDevices.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDBOOTDEVICES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedBootDevices.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDBOOTDEVICES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDBOOTDEVICES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedStorageBuses)(ComSafeArrayOut(StorageBus_T, aSupportedStorageBuses))
{
    LogRelFlow(("{%p} %s: enter aSupportedStorageBuses=%p\n", this, "PlatformProperties::getSupportedStorageBuses", aSupportedStorageBuses));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedStorageBuses);
        ArrayOutConverter<StorageBus_T> TmpSupportedStorageBuses(ComSafeArrayOutArg(aSupportedStorageBuses));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGEBUSES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedStorageBuses(TmpSupportedStorageBuses.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGEBUSES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedStorageBuses.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGEBUSES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGEBUSES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedStorageControllerTypes)(ComSafeArrayOut(StorageControllerType_T, aSupportedStorageControllerTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedStorageControllerTypes=%p\n", this, "PlatformProperties::getSupportedStorageControllerTypes", aSupportedStorageControllerTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedStorageControllerTypes);
        ArrayOutConverter<StorageControllerType_T> TmpSupportedStorageControllerTypes(ComSafeArrayOutArg(aSupportedStorageControllerTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGECONTROLLERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedStorageControllerTypes(TmpSupportedStorageControllerTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGECONTROLLERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedStorageControllerTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGECONTROLLERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDSTORAGECONTROLLERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedChipsetTypes)(ComSafeArrayOut(ChipsetType_T, aSupportedChipsetTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedChipsetTypes=%p\n", this, "PlatformProperties::getSupportedChipsetTypes", aSupportedChipsetTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedChipsetTypes);
        ArrayOutConverter<ChipsetType_T> TmpSupportedChipsetTypes(ComSafeArrayOutArg(aSupportedChipsetTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDCHIPSETTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedChipsetTypes(TmpSupportedChipsetTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDCHIPSETTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedChipsetTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDCHIPSETTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDCHIPSETTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedIommuTypes)(ComSafeArrayOut(IommuType_T, aSupportedIommuTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedIommuTypes=%p\n", this, "PlatformProperties::getSupportedIommuTypes", aSupportedIommuTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedIommuTypes);
        ArrayOutConverter<IommuType_T> TmpSupportedIommuTypes(ComSafeArrayOutArg(aSupportedIommuTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDIOMMUTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedIommuTypes(TmpSupportedIommuTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDIOMMUTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedIommuTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDIOMMUTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDIOMMUTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(SupportedTpmTypes)(ComSafeArrayOut(TpmType_T, aSupportedTpmTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedTpmTypes=%p\n", this, "PlatformProperties::getSupportedTpmTypes", aSupportedTpmTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedTpmTypes);
        ArrayOutConverter<TpmType_T> TmpSupportedTpmTypes(ComSafeArrayOutArg(aSupportedTpmTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDTPMTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedTpmTypes(TmpSupportedTpmTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDTPMTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedTpmTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDTPMTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GET_SUPPORTEDTPMTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute1IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute2IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute3IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute4IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute5IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute6IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute7IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute8IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute9IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute10IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute11IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute12IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute13IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute14IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute15IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::COMGETTER(InternalAndReservedAttribute16IPlatformProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPlatformProperties methods
//

STDMETHODIMP PlatformPropertiesWrap::GetMaxNetworkAdapters(ChipsetType_T aChipset,
                                                           ULONG *aMaxNetworkAdapters)
{
    LogRelFlow(("{%p} %s: enter aChipset=%RU32 aMaxNetworkAdapters=%p\n", this, "PlatformProperties::getMaxNetworkAdapters", aChipset, aMaxNetworkAdapters));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxNetworkAdapters);


        
        

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

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

STDMETHODIMP PlatformPropertiesWrap::GetMaxNetworkAdaptersOfType(ChipsetType_T aChipset,
                                                                 NetworkAttachmentType_T aType,
                                                                 ULONG *aMaxNetworkAdapters)
{
    LogRelFlow(("{%p} %s: enter aChipset=%RU32 aType=%RU32 aMaxNetworkAdapters=%p\n", this, "PlatformProperties::getMaxNetworkAdaptersOfType", aChipset, aType, aMaxNetworkAdapters));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxNetworkAdapters);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXNETWORKADAPTERSOFTYPE_ENTER(this, aChipset, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxNetworkAdaptersOfType(aChipset,
                                              aType,
                                              aMaxNetworkAdapters);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXNETWORKADAPTERSOFTYPE_RETURN(this, hrc, 0 /*normal*/, aChipset, aType, *aMaxNetworkAdapters);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXNETWORKADAPTERSOFTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aChipset, aType, *aMaxNetworkAdapters);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXNETWORKADAPTERSOFTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aChipset, aType, *aMaxNetworkAdapters);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
                                                                       ULONG *aMaxDevicesPerPort)
{
    LogRelFlow(("{%p} %s: enter aBus=%RU32 aMaxDevicesPerPort=%p\n", this, "PlatformProperties::getMaxDevicesPerPortForStorageBus", aBus, aMaxDevicesPerPort));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxDevicesPerPort);


        
        

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

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

STDMETHODIMP PlatformPropertiesWrap::GetMinPortCountForStorageBus(StorageBus_T aBus,
                                                                  ULONG *aMinPortCount)
{
    LogRelFlow(("{%p} %s: enter aBus=%RU32 aMinPortCount=%p\n", this, "PlatformProperties::getMinPortCountForStorageBus", aBus, 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_PLATFORMPROPERTIES_GETMINPORTCOUNTFORSTORAGEBUS_ENTER(this, aBus);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinPortCountForStorageBus(aBus,
                                               aMinPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMINPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/, aBus, *aMinPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMINPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/, aBus, *aMinPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMINPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/, aBus, *aMinPortCount);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetMaxPortCountForStorageBus(StorageBus_T aBus,
                                                                  ULONG *aMaxPortCount)
{
    LogRelFlow(("{%p} %s: enter aBus=%RU32 aMaxPortCount=%p\n", this, "PlatformProperties::getMaxPortCountForStorageBus", aBus, 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_PLATFORMPROPERTIES_GETMAXPORTCOUNTFORSTORAGEBUS_ENTER(this, aBus);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxPortCountForStorageBus(aBus,
                                               aMaxPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/, aBus, *aMaxPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/, aBus, *aMaxPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXPORTCOUNTFORSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/, aBus, *aMaxPortCount);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetMaxInstancesOfStorageBus(ChipsetType_T aChipset,
                                                                 StorageBus_T aBus,
                                                                 ULONG *aMaxInstances)
{
    LogRelFlow(("{%p} %s: enter aChipset=%RU32 aBus=%RU32 aMaxInstances=%p\n", this, "PlatformProperties::getMaxInstancesOfStorageBus", aChipset, aBus, aMaxInstances));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxInstances);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFSTORAGEBUS_ENTER(this, aChipset, aBus);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxInstancesOfStorageBus(aChipset,
                                              aBus,
                                              aMaxInstances);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/, aChipset, aBus, *aMaxInstances);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/, aChipset, aBus, *aMaxInstances);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/, aChipset, aBus, *aMaxInstances);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetSupportedVRAMRange(GraphicsControllerType_T aGraphicsControllerType,
                                                           BOOL aAccelerate3DEnabled,
                                                           ULONG *aMinMB,
                                                           ULONG *aMaxMB,
                                                           ULONG *aStrideSizeMB)
{
    LogRelFlow(("{%p} %s: enter aGraphicsControllerType=%RU32 aAccelerate3DEnabled=%RTbool aMinMB=%p aMaxMB=%p aStrideSizeMB=%p\n", this, "PlatformProperties::getSupportedVRAMRange", aGraphicsControllerType, aAccelerate3DEnabled, aMinMB, aMaxMB, aStrideSizeMB));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinMB);
        CheckComArgOutPointerValidThrow(aMaxMB);
        CheckComArgOutPointerValidThrow(aStrideSizeMB);


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSUPPORTEDVRAMRANGE_ENTER(this, aGraphicsControllerType, aAccelerate3DEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedVRAMRange(aGraphicsControllerType,
                                        aAccelerate3DEnabled != FALSE,
                                        aMinMB,
                                        aMaxMB,
                                        aStrideSizeMB);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSUPPORTEDVRAMRANGE_RETURN(this, hrc, 0 /*normal*/, aGraphicsControllerType, aAccelerate3DEnabled != FALSE, *aMinMB, *aMaxMB, *aStrideSizeMB);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSUPPORTEDVRAMRANGE_RETURN(this, hrc, 1 /*hrc exception*/, aGraphicsControllerType, aAccelerate3DEnabled != FALSE, *aMinMB, *aMaxMB, *aStrideSizeMB);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSUPPORTEDVRAMRANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aGraphicsControllerType, aAccelerate3DEnabled != FALSE, *aMinMB, *aMaxMB, *aStrideSizeMB);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinMB=%RU32 *aMaxMB=%RU32 aStrideSizeMB=%RU32 hrc=%Rhrc\n", this, "PlatformProperties::getSupportedVRAMRange", !RT_VALID_PTR(aMinMB) ? 0 : *aMinMB, !RT_VALID_PTR(aMaxMB) ? 0 : *aMaxMB, !RT_VALID_PTR(aStrideSizeMB) ? 0 : *aStrideSizeMB, hrc));
    return hrc;
}

STDMETHODIMP PlatformPropertiesWrap::GetSupportedGfxFeaturesForType(GraphicsControllerType_T aGraphicsControllerType,
                                                                    ComSafeArrayOut(GraphicsFeature_T, aSupportedControllerFeatures))
{
    LogRelFlow(("{%p} %s: enter aGraphicsControllerType=%RU32 aSupportedControllerFeatures=%p\n", this, "PlatformProperties::getSupportedGfxFeaturesForType", aGraphicsControllerType, aSupportedControllerFeatures));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedControllerFeatures);


        
        ArrayOutConverter<GraphicsFeature_T> TmpSupportedControllerFeatures(ComSafeArrayOutArg(aSupportedControllerFeatures));

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

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

STDMETHODIMP PlatformPropertiesWrap::GetDeviceTypesForStorageBus(StorageBus_T aBus,
                                                                 ComSafeArrayOut(DeviceType_T, aDeviceTypes))
{
    LogRelFlow(("{%p} %s: enter aBus=%RU32 aDeviceTypes=%p\n", this, "PlatformProperties::getDeviceTypesForStorageBus", aBus, aDeviceTypes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceTypes);


        
        ArrayOutConverter<DeviceType_T> TmpDeviceTypes(ComSafeArrayOutArg(aDeviceTypes));

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

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

STDMETHODIMP PlatformPropertiesWrap::GetStorageBusForControllerType(StorageControllerType_T aStorageControllerType,
                                                                    StorageBus_T *aStorageBus)
{
    LogRelFlow(("{%p} %s: enter aStorageControllerType=%RU32 aStorageBus=%p\n", this, "PlatformProperties::getStorageBusForControllerType", aStorageControllerType, aStorageBus));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStorageBus);


        
        

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

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

STDMETHODIMP PlatformPropertiesWrap::GetStorageControllerTypesForBus(StorageBus_T aStorageBus,
                                                                     ComSafeArrayOut(StorageControllerType_T, aStorageControllerType))
{
    LogRelFlow(("{%p} %s: enter aStorageBus=%RU32 aStorageControllerType=%p\n", this, "PlatformProperties::getStorageControllerTypesForBus", aStorageBus, aStorageControllerType));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStorageControllerType);


        
        ArrayOutConverter<StorageControllerType_T> TmpStorageControllerType(ComSafeArrayOutArg(aStorageControllerType));

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

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

STDMETHODIMP PlatformPropertiesWrap::GetStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
                                                                        BOOL *aHotplugCapable)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%RU32 aHotplugCapable=%p\n", this, "PlatformProperties::getStorageControllerHotplugCapable", aControllerType, aHotplugCapable));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotplugCapable);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSTORAGECONTROLLERHOTPLUGCAPABLE_ENTER(this, aControllerType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStorageControllerHotplugCapable(aControllerType,
                                                     aHotplugCapable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSTORAGECONTROLLERHOTPLUGCAPABLE_RETURN(this, hrc, 0 /*normal*/, aControllerType, *aHotplugCapable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSTORAGECONTROLLERHOTPLUGCAPABLE_RETURN(this, hrc, 1 /*hrc exception*/, aControllerType, *aHotplugCapable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETSTORAGECONTROLLERHOTPLUGCAPABLE_RETURN(this, hrc, 9 /*unhandled exception*/, aControllerType, *aHotplugCapable != FALSE);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
                                                                        USBControllerType_T aType,
                                                                        ULONG *aMaxInstances)
{
    LogRelFlow(("{%p} %s: enter aChipset=%RU32 aType=%RU32 aMaxInstances=%p\n", this, "PlatformProperties::getMaxInstancesOfUSBControllerType", aChipset, aType, aMaxInstances));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxInstances);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFUSBCONTROLLERTYPE_ENTER(this, aChipset, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxInstancesOfUSBControllerType(aChipset,
                                                     aType,
                                                     aMaxInstances);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFUSBCONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/, aChipset, aType, *aMaxInstances);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFUSBCONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aChipset, aType, *aMaxInstances);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PLATFORMPROPERTIES_GETMAXINSTANCESOFUSBCONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aChipset, aType, *aMaxInstances);
#endif
    }

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

STDMETHODIMP PlatformPropertiesWrap::GetMinGuestRAM(FirmwareType_T aFirmware,
                                                    ULONG *aMinMegabytes)
{
    LogRelFlow(("{%p} %s: enter aFirmware=%RU32 aMinMegabytes=%p\n", this, "PlatformProperties::getMinGuestRAM", aFirmware, aMinMegabytes));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinMegabytes);


        
        

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

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

STDMETHODIMP PlatformPropertiesWrap::InternalAndReservedMethod1IPlatformProperties()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::InternalAndReservedMethod2IPlatformProperties()
{
    return E_NOTIMPL;
}

STDMETHODIMP PlatformPropertiesWrap::InternalAndReservedMethod3IPlatformProperties()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PlatformPropertiesWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PlatformPropertiesWrap, IPlatformProperties)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PlatformPropertiesWrap.cpp"


// ##### BEGINFILE "SystemPropertiesWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISystemProperties.
 *
 * 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_SYSTEMPROPERTIES

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

DEFINE_EMPTY_CTOR_DTOR(SystemPropertiesWrap)

//
// ISystemProperties properties
//

STDMETHODIMP SystemPropertiesWrap::COMGETTER(Platform)(IPlatformProperties **aPlatform)
{
    LogRelFlow(("{%p} %s: enter aPlatform=%p\n", this, "SystemProperties::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<IPlatformProperties> TmpPlatform(aPlatform);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_GET_PLATFORM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpPlatform.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_GET_PLATFORM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MinGuestRAM)(ULONG *aMinGuestRAM)
{
    LogRelFlow(("{%p} %s: enter aMinGuestRAM=%p\n", this, "SystemProperties::getMinGuestRAM", aMinGuestRAM));

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

    HRESULT hrc;

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

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MaxGuestRAM)(ULONG *aMaxGuestRAM)
{
    LogRelFlow(("{%p} %s: enter aMaxGuestRAM=%p\n", this, "SystemProperties::getMaxGuestRAM", aMaxGuestRAM));

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

    HRESULT hrc;

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

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MinGuestVRAM)(ULONG *aMinGuestVRAM)
{
    LogRelFlow(("{%p} %s: enter aMinGuestVRAM=%p\n", this, "SystemProperties::getMinGuestVRAM", aMinGuestVRAM));

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

    HRESULT hrc;

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

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MaxGuestVRAM)(ULONG *aMaxGuestVRAM)
{
    LogRelFlow(("{%p} %s: enter aMaxGuestVRAM=%p\n", this, "SystemProperties::getMaxGuestVRAM", aMaxGuestVRAM));

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

    HRESULT hrc;

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

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MinGuestCPUCount)(ULONG *aMinGuestCPUCount)
{
    LogRelFlow(("{%p} %s: enter aMinGuestCPUCount=%p\n", this, "SystemProperties::getMinGuestCPUCount", aMinGuestCPUCount));

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

    HRESULT hrc;

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

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

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MaxGuestCPUCount)(ULONG *aMaxGuestCPUCount)
{
    LogRelFlow(("{%p} %s: enter aMaxGuestCPUCount=%p\n", this, "SystemProperties::getMaxGuestCPUCount", aMaxGuestCPUCount));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxGuestCPUCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTCPUCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxGuestCPUCount(aMaxGuestCPUCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTCPUCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMaxGuestCPUCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTCPUCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxGuestCPUCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTCPUCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxGuestCPUCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxGuestCPUCount=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getMaxGuestCPUCount", !RT_VALID_PTR(aMaxGuestCPUCount) ? 0 : *aMaxGuestCPUCount, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MaxGuestMonitors)(ULONG *aMaxGuestMonitors)
{
    LogRelFlow(("{%p} %s: enter aMaxGuestMonitors=%p\n", this, "SystemProperties::getMaxGuestMonitors", aMaxGuestMonitors));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxGuestMonitors);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTMONITORS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxGuestMonitors(aMaxGuestMonitors);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTMONITORS_RETURN(this, hrc, 0 /*normal*/,*aMaxGuestMonitors);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTMONITORS_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxGuestMonitors);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MAXGUESTMONITORS_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxGuestMonitors);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxGuestMonitors=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getMaxGuestMonitors", !RT_VALID_PTR(aMaxGuestMonitors) ? 0 : *aMaxGuestMonitors, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InfoVDSize)(LONG64 *aInfoVDSize)
{
    LogRelFlow(("{%p} %s: enter aInfoVDSize=%p\n", this, "SystemProperties::getInfoVDSize", aInfoVDSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInfoVDSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_INFOVDSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInfoVDSize(aInfoVDSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_INFOVDSIZE_RETURN(this, hrc, 0 /*normal*/,*aInfoVDSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_INFOVDSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aInfoVDSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_INFOVDSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInfoVDSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInfoVDSize=%RI64 hrc=%Rhrc\n", this, "SystemProperties::getInfoVDSize", !RT_VALID_PTR(aInfoVDSize) ? 0 : *aInfoVDSize, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultMachineFolder)(BSTR *aDefaultMachineFolder)
{
    LogRelFlow(("{%p} %s: enter aDefaultMachineFolder=%p\n", this, "SystemProperties::getDefaultMachineFolder", aDefaultMachineFolder));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultMachineFolder);
        BSTROutConverter TmpDefaultMachineFolder(aDefaultMachineFolder);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTMACHINEFOLDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultMachineFolder(TmpDefaultMachineFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpDefaultMachineFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultMachineFolder=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultMachineFolder", !RT_VALID_PTR(aDefaultMachineFolder) ? 0 : *aDefaultMachineFolder, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultMachineFolder)(IN_BSTR aDefaultMachineFolder)
{
    LogRelFlow(("{%p} %s: enter aDefaultMachineFolder=%ls\n", this, "SystemProperties::setDefaultMachineFolder", aDefaultMachineFolder));

    // Clear 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 TmpDefaultMachineFolder(aDefaultMachineFolder);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTMACHINEFOLDER_ENTER(this, TmpDefaultMachineFolder.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultMachineFolder(TmpDefaultMachineFolder.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 0 /*normal*/,TmpDefaultMachineFolder.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTMACHINEFOLDER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultMachineFolder", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(LoggingLevel)(BSTR *aLoggingLevel)
{
    LogRelFlow(("{%p} %s: enter aLoggingLevel=%p\n", this, "SystemProperties::getLoggingLevel", aLoggingLevel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLoggingLevel);
        BSTROutConverter TmpLoggingLevel(aLoggingLevel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGGINGLEVEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLoggingLevel(TmpLoggingLevel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGGINGLEVEL_RETURN(this, hrc, 0 /*normal*/,TmpLoggingLevel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGGINGLEVEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGGINGLEVEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLoggingLevel=%ls hrc=%Rhrc\n", this, "SystemProperties::getLoggingLevel", !RT_VALID_PTR(aLoggingLevel) ? 0 : *aLoggingLevel, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(LoggingLevel)(IN_BSTR aLoggingLevel)
{
    LogRelFlow(("{%p} %s: enter aLoggingLevel=%ls\n", this, "SystemProperties::setLoggingLevel", aLoggingLevel));

    // Clear 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 TmpLoggingLevel(aLoggingLevel);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGGINGLEVEL_ENTER(this, TmpLoggingLevel.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLoggingLevel(TmpLoggingLevel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGGINGLEVEL_RETURN(this, hrc, 0 /*normal*/,TmpLoggingLevel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGGINGLEVEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGGINGLEVEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setLoggingLevel", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(MediumFormats)(ComSafeArrayOut(IMediumFormat *, aMediumFormats))
{
    LogRelFlow(("{%p} %s: enter aMediumFormats=%p\n", this, "SystemProperties::getMediumFormats", aMediumFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMediumFormats);
        ArrayComTypeOutConverter<IMediumFormat> TmpMediumFormats(ComSafeArrayOutArg(aMediumFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MEDIUMFORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumFormats(TmpMediumFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MEDIUMFORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMediumFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MEDIUMFORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_MEDIUMFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMediumFormats=%zu hrc=%Rhrc\n", this, "SystemProperties::getMediumFormats", !RT_VALID_PTR(aMediumFormats) ? 0 : ComSafeArraySize(*aMediumFormats), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultHardDiskFormat)(BSTR *aDefaultHardDiskFormat)
{
    LogRelFlow(("{%p} %s: enter aDefaultHardDiskFormat=%p\n", this, "SystemProperties::getDefaultHardDiskFormat", aDefaultHardDiskFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultHardDiskFormat);
        BSTROutConverter TmpDefaultHardDiskFormat(aDefaultHardDiskFormat);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTHARDDISKFORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultHardDiskFormat(TmpDefaultHardDiskFormat.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 0 /*normal*/,TmpDefaultHardDiskFormat.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultHardDiskFormat=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultHardDiskFormat", !RT_VALID_PTR(aDefaultHardDiskFormat) ? 0 : *aDefaultHardDiskFormat, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultHardDiskFormat)(IN_BSTR aDefaultHardDiskFormat)
{
    LogRelFlow(("{%p} %s: enter aDefaultHardDiskFormat=%ls\n", this, "SystemProperties::setDefaultHardDiskFormat", aDefaultHardDiskFormat));

    // Clear 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 TmpDefaultHardDiskFormat(aDefaultHardDiskFormat);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTHARDDISKFORMAT_ENTER(this, TmpDefaultHardDiskFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultHardDiskFormat(TmpDefaultHardDiskFormat.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 0 /*normal*/,TmpDefaultHardDiskFormat.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTHARDDISKFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultHardDiskFormat", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(FreeDiskSpaceWarning)(LONG64 *aFreeDiskSpaceWarning)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpaceWarning=%p\n", this, "SystemProperties::getFreeDiskSpaceWarning", aFreeDiskSpaceWarning));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeDiskSpaceWarning);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEWARNING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeDiskSpaceWarning(aFreeDiskSpaceWarning);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEWARNING_RETURN(this, hrc, 0 /*normal*/,*aFreeDiskSpaceWarning);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEWARNING_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeDiskSpaceWarning);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEWARNING_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeDiskSpaceWarning);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeDiskSpaceWarning=%RI64 hrc=%Rhrc\n", this, "SystemProperties::getFreeDiskSpaceWarning", !RT_VALID_PTR(aFreeDiskSpaceWarning) ? 0 : *aFreeDiskSpaceWarning, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(FreeDiskSpaceWarning)(LONG64 aFreeDiskSpaceWarning)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpaceWarning=%RI64\n", this, "SystemProperties::setFreeDiskSpaceWarning", aFreeDiskSpaceWarning));

    // Clear 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_SYSTEMPROPERTIES_SET_FREEDISKSPACEWARNING_ENTER(this, aFreeDiskSpaceWarning);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFreeDiskSpaceWarning(aFreeDiskSpaceWarning);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEWARNING_RETURN(this, hrc, 0 /*normal*/,aFreeDiskSpaceWarning);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEWARNING_RETURN(this, hrc, 1 /*hrc exception*/,aFreeDiskSpaceWarning);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEWARNING_RETURN(this, hrc, 9 /*unhandled exception*/,aFreeDiskSpaceWarning);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setFreeDiskSpaceWarning", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(FreeDiskSpacePercentWarning)(ULONG *aFreeDiskSpacePercentWarning)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpacePercentWarning=%p\n", this, "SystemProperties::getFreeDiskSpacePercentWarning", aFreeDiskSpacePercentWarning));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeDiskSpacePercentWarning);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTWARNING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeDiskSpacePercentWarning(aFreeDiskSpacePercentWarning);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 0 /*normal*/,*aFreeDiskSpacePercentWarning);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeDiskSpacePercentWarning);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeDiskSpacePercentWarning);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeDiskSpacePercentWarning=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getFreeDiskSpacePercentWarning", !RT_VALID_PTR(aFreeDiskSpacePercentWarning) ? 0 : *aFreeDiskSpacePercentWarning, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(FreeDiskSpacePercentWarning)(ULONG aFreeDiskSpacePercentWarning)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpacePercentWarning=%RU32\n", this, "SystemProperties::setFreeDiskSpacePercentWarning", aFreeDiskSpacePercentWarning));

    // Clear 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_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTWARNING_ENTER(this, aFreeDiskSpacePercentWarning);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFreeDiskSpacePercentWarning(aFreeDiskSpacePercentWarning);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 0 /*normal*/,aFreeDiskSpacePercentWarning);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 1 /*hrc exception*/,aFreeDiskSpacePercentWarning);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTWARNING_RETURN(this, hrc, 9 /*unhandled exception*/,aFreeDiskSpacePercentWarning);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setFreeDiskSpacePercentWarning", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(FreeDiskSpaceError)(LONG64 *aFreeDiskSpaceError)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpaceError=%p\n", this, "SystemProperties::getFreeDiskSpaceError", aFreeDiskSpaceError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeDiskSpaceError);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEERROR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeDiskSpaceError(aFreeDiskSpaceError);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEERROR_RETURN(this, hrc, 0 /*normal*/,*aFreeDiskSpaceError);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEERROR_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeDiskSpaceError);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEERROR_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeDiskSpaceError);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeDiskSpaceError=%RI64 hrc=%Rhrc\n", this, "SystemProperties::getFreeDiskSpaceError", !RT_VALID_PTR(aFreeDiskSpaceError) ? 0 : *aFreeDiskSpaceError, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(FreeDiskSpaceError)(LONG64 aFreeDiskSpaceError)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpaceError=%RI64\n", this, "SystemProperties::setFreeDiskSpaceError", aFreeDiskSpaceError));

    // Clear 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_SYSTEMPROPERTIES_SET_FREEDISKSPACEERROR_ENTER(this, aFreeDiskSpaceError);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFreeDiskSpaceError(aFreeDiskSpaceError);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEERROR_RETURN(this, hrc, 0 /*normal*/,aFreeDiskSpaceError);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEERROR_RETURN(this, hrc, 1 /*hrc exception*/,aFreeDiskSpaceError);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEERROR_RETURN(this, hrc, 9 /*unhandled exception*/,aFreeDiskSpaceError);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setFreeDiskSpaceError", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(FreeDiskSpacePercentError)(ULONG *aFreeDiskSpacePercentError)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpacePercentError=%p\n", this, "SystemProperties::getFreeDiskSpacePercentError", aFreeDiskSpacePercentError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeDiskSpacePercentError);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTERROR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeDiskSpacePercentError(aFreeDiskSpacePercentError);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 0 /*normal*/,*aFreeDiskSpacePercentError);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeDiskSpacePercentError);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeDiskSpacePercentError);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeDiskSpacePercentError=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getFreeDiskSpacePercentError", !RT_VALID_PTR(aFreeDiskSpacePercentError) ? 0 : *aFreeDiskSpacePercentError, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(FreeDiskSpacePercentError)(ULONG aFreeDiskSpacePercentError)
{
    LogRelFlow(("{%p} %s: enter aFreeDiskSpacePercentError=%RU32\n", this, "SystemProperties::setFreeDiskSpacePercentError", aFreeDiskSpacePercentError));

    // Clear 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_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTERROR_ENTER(this, aFreeDiskSpacePercentError);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFreeDiskSpacePercentError(aFreeDiskSpacePercentError);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 0 /*normal*/,aFreeDiskSpacePercentError);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 1 /*hrc exception*/,aFreeDiskSpacePercentError);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_FREEDISKSPACEPERCENTERROR_RETURN(this, hrc, 9 /*unhandled exception*/,aFreeDiskSpacePercentError);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setFreeDiskSpacePercentError", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(VRDEAuthLibrary)(BSTR *aVRDEAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aVRDEAuthLibrary=%p\n", this, "SystemProperties::getVRDEAuthLibrary", aVRDEAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEAuthLibrary);
        BSTROutConverter TmpVRDEAuthLibrary(aVRDEAuthLibrary);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_VRDEAUTHLIBRARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEAuthLibrary(TmpVRDEAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_VRDEAUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpVRDEAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_VRDEAUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_VRDEAUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEAuthLibrary=%ls hrc=%Rhrc\n", this, "SystemProperties::getVRDEAuthLibrary", !RT_VALID_PTR(aVRDEAuthLibrary) ? 0 : *aVRDEAuthLibrary, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(VRDEAuthLibrary)(IN_BSTR aVRDEAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aVRDEAuthLibrary=%ls\n", this, "SystemProperties::setVRDEAuthLibrary", aVRDEAuthLibrary));

    // Clear 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 TmpVRDEAuthLibrary(aVRDEAuthLibrary);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_VRDEAUTHLIBRARY_ENTER(this, TmpVRDEAuthLibrary.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRDEAuthLibrary(TmpVRDEAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_VRDEAUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpVRDEAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_VRDEAUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_VRDEAUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setVRDEAuthLibrary", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(WebServiceAuthLibrary)(BSTR *aWebServiceAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aWebServiceAuthLibrary=%p\n", this, "SystemProperties::getWebServiceAuthLibrary", aWebServiceAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWebServiceAuthLibrary);
        BSTROutConverter TmpWebServiceAuthLibrary(aWebServiceAuthLibrary);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_WEBSERVICEAUTHLIBRARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWebServiceAuthLibrary(TmpWebServiceAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpWebServiceAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWebServiceAuthLibrary=%ls hrc=%Rhrc\n", this, "SystemProperties::getWebServiceAuthLibrary", !RT_VALID_PTR(aWebServiceAuthLibrary) ? 0 : *aWebServiceAuthLibrary, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(WebServiceAuthLibrary)(IN_BSTR aWebServiceAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aWebServiceAuthLibrary=%ls\n", this, "SystemProperties::setWebServiceAuthLibrary", aWebServiceAuthLibrary));

    // Clear 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 TmpWebServiceAuthLibrary(aWebServiceAuthLibrary);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_WEBSERVICEAUTHLIBRARY_ENTER(this, TmpWebServiceAuthLibrary.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setWebServiceAuthLibrary(TmpWebServiceAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpWebServiceAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_WEBSERVICEAUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setWebServiceAuthLibrary", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultVRDEExtPack)(BSTR *aDefaultVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aDefaultVRDEExtPack=%p\n", this, "SystemProperties::getDefaultVRDEExtPack", aDefaultVRDEExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultVRDEExtPack);
        BSTROutConverter TmpDefaultVRDEExtPack(aDefaultVRDEExtPack);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTVRDEEXTPACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultVRDEExtPack(TmpDefaultVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpDefaultVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultVRDEExtPack=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultVRDEExtPack", !RT_VALID_PTR(aDefaultVRDEExtPack) ? 0 : *aDefaultVRDEExtPack, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultVRDEExtPack)(IN_BSTR aDefaultVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aDefaultVRDEExtPack=%ls\n", this, "SystemProperties::setDefaultVRDEExtPack", aDefaultVRDEExtPack));

    // Clear 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 TmpDefaultVRDEExtPack(aDefaultVRDEExtPack);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTVRDEEXTPACK_ENTER(this, TmpDefaultVRDEExtPack.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultVRDEExtPack(TmpDefaultVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpDefaultVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTVRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultVRDEExtPack", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultCryptoExtPack)(BSTR *aDefaultCryptoExtPack)
{
    LogRelFlow(("{%p} %s: enter aDefaultCryptoExtPack=%p\n", this, "SystemProperties::getDefaultCryptoExtPack", aDefaultCryptoExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultCryptoExtPack);
        BSTROutConverter TmpDefaultCryptoExtPack(aDefaultCryptoExtPack);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTCRYPTOEXTPACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultCryptoExtPack(TmpDefaultCryptoExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpDefaultCryptoExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultCryptoExtPack=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultCryptoExtPack", !RT_VALID_PTR(aDefaultCryptoExtPack) ? 0 : *aDefaultCryptoExtPack, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultCryptoExtPack)(IN_BSTR aDefaultCryptoExtPack)
{
    LogRelFlow(("{%p} %s: enter aDefaultCryptoExtPack=%ls\n", this, "SystemProperties::setDefaultCryptoExtPack", aDefaultCryptoExtPack));

    // Clear 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 TmpDefaultCryptoExtPack(aDefaultCryptoExtPack);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTCRYPTOEXTPACK_ENTER(this, TmpDefaultCryptoExtPack.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultCryptoExtPack(TmpDefaultCryptoExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpDefaultCryptoExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTCRYPTOEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultCryptoExtPack", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(LogHistoryCount)(ULONG *aLogHistoryCount)
{
    LogRelFlow(("{%p} %s: enter aLogHistoryCount=%p\n", this, "SystemProperties::getLogHistoryCount", aLogHistoryCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogHistoryCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGHISTORYCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogHistoryCount(aLogHistoryCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGHISTORYCOUNT_RETURN(this, hrc, 0 /*normal*/,*aLogHistoryCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGHISTORYCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aLogHistoryCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LOGHISTORYCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogHistoryCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogHistoryCount=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getLogHistoryCount", !RT_VALID_PTR(aLogHistoryCount) ? 0 : *aLogHistoryCount, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(LogHistoryCount)(ULONG aLogHistoryCount)
{
    LogRelFlow(("{%p} %s: enter aLogHistoryCount=%RU32\n", this, "SystemProperties::setLogHistoryCount", aLogHistoryCount));

    // Clear 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_SYSTEMPROPERTIES_SET_LOGHISTORYCOUNT_ENTER(this, aLogHistoryCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogHistoryCount(aLogHistoryCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGHISTORYCOUNT_RETURN(this, hrc, 0 /*normal*/,aLogHistoryCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGHISTORYCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aLogHistoryCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LOGHISTORYCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aLogHistoryCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setLogHistoryCount", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultAudioDriver)(AudioDriverType_T *aDefaultAudioDriver)
{
    LogRelFlow(("{%p} %s: enter aDefaultAudioDriver=%p\n", this, "SystemProperties::getDefaultAudioDriver", aDefaultAudioDriver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultAudioDriver);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTAUDIODRIVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultAudioDriver(aDefaultAudioDriver);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTAUDIODRIVER_RETURN(this, hrc, 0 /*normal*/,*aDefaultAudioDriver);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTAUDIODRIVER_RETURN(this, hrc, 1 /*hrc exception*/,*aDefaultAudioDriver);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTAUDIODRIVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultAudioDriver);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultAudioDriver=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getDefaultAudioDriver", !RT_VALID_PTR(aDefaultAudioDriver) ? 0 : *aDefaultAudioDriver, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(AutostartDatabasePath)(BSTR *aAutostartDatabasePath)
{
    LogRelFlow(("{%p} %s: enter aAutostartDatabasePath=%p\n", this, "SystemProperties::getAutostartDatabasePath", aAutostartDatabasePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutostartDatabasePath);
        BSTROutConverter TmpAutostartDatabasePath(aAutostartDatabasePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_AUTOSTARTDATABASEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutostartDatabasePath(TmpAutostartDatabasePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 0 /*normal*/,TmpAutostartDatabasePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutostartDatabasePath=%ls hrc=%Rhrc\n", this, "SystemProperties::getAutostartDatabasePath", !RT_VALID_PTR(aAutostartDatabasePath) ? 0 : *aAutostartDatabasePath, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(AutostartDatabasePath)(IN_BSTR aAutostartDatabasePath)
{
    LogRelFlow(("{%p} %s: enter aAutostartDatabasePath=%ls\n", this, "SystemProperties::setAutostartDatabasePath", aAutostartDatabasePath));

    // Clear 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 TmpAutostartDatabasePath(aAutostartDatabasePath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_AUTOSTARTDATABASEPATH_ENTER(this, TmpAutostartDatabasePath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutostartDatabasePath(TmpAutostartDatabasePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 0 /*normal*/,TmpAutostartDatabasePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_AUTOSTARTDATABASEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setAutostartDatabasePath", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultAdditionsISO)(BSTR *aDefaultAdditionsISO)
{
    LogRelFlow(("{%p} %s: enter aDefaultAdditionsISO=%p\n", this, "SystemProperties::getDefaultAdditionsISO", aDefaultAdditionsISO));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultAdditionsISO);
        BSTROutConverter TmpDefaultAdditionsISO(aDefaultAdditionsISO);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTADDITIONSISO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultAdditionsISO(TmpDefaultAdditionsISO.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTADDITIONSISO_RETURN(this, hrc, 0 /*normal*/,TmpDefaultAdditionsISO.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTADDITIONSISO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_DEFAULTADDITIONSISO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultAdditionsISO=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultAdditionsISO", !RT_VALID_PTR(aDefaultAdditionsISO) ? 0 : *aDefaultAdditionsISO, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultAdditionsISO)(IN_BSTR aDefaultAdditionsISO)
{
    LogRelFlow(("{%p} %s: enter aDefaultAdditionsISO=%ls\n", this, "SystemProperties::setDefaultAdditionsISO", aDefaultAdditionsISO));

    // Clear 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 TmpDefaultAdditionsISO(aDefaultAdditionsISO);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTADDITIONSISO_ENTER(this, TmpDefaultAdditionsISO.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultAdditionsISO(TmpDefaultAdditionsISO.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTADDITIONSISO_RETURN(this, hrc, 0 /*normal*/,TmpDefaultAdditionsISO.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTADDITIONSISO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_DEFAULTADDITIONSISO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultAdditionsISO", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(DefaultFrontend)(BSTR *aDefaultFrontend)
{
    LogRelFlow(("{%p} %s: enter aDefaultFrontend=%p\n", this, "SystemProperties::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_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_GET_DEFAULTFRONTEND_RETURN(this, hrc, 0 /*normal*/,TmpDefaultFrontend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_GET_DEFAULTFRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultFrontend=%ls hrc=%Rhrc\n", this, "SystemProperties::getDefaultFrontend", !RT_VALID_PTR(aDefaultFrontend) ? 0 : *aDefaultFrontend, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(DefaultFrontend)(IN_BSTR aDefaultFrontend)
{
    LogRelFlow(("{%p} %s: enter aDefaultFrontend=%ls\n", this, "SystemProperties::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_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_SET_DEFAULTFRONTEND_RETURN(this, hrc, 0 /*normal*/,TmpDefaultFrontend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_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_SYSTEMPROPERTIES_SET_DEFAULTFRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setDefaultFrontend", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(ScreenShotFormats)(ComSafeArrayOut(BitmapFormat_T, aScreenShotFormats))
{
    LogRelFlow(("{%p} %s: enter aScreenShotFormats=%p\n", this, "SystemProperties::getScreenShotFormats", aScreenShotFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenShotFormats);
        ArrayOutConverter<BitmapFormat_T> TmpScreenShotFormats(ComSafeArrayOutArg(aScreenShotFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SCREENSHOTFORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenShotFormats(TmpScreenShotFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SCREENSHOTFORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpScreenShotFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SCREENSHOTFORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SCREENSHOTFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreenShotFormats=%zu hrc=%Rhrc\n", this, "SystemProperties::getScreenShotFormats", !RT_VALID_PTR(aScreenShotFormats) ? 0 : ComSafeArraySize(*aScreenShotFormats), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(ProxyMode)(ProxyMode_T *aProxyMode)
{
    LogRelFlow(("{%p} %s: enter aProxyMode=%p\n", this, "SystemProperties::getProxyMode", aProxyMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProxyMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProxyMode(aProxyMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYMODE_RETURN(this, hrc, 0 /*normal*/,*aProxyMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aProxyMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aProxyMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProxyMode=%RU32 hrc=%Rhrc\n", this, "SystemProperties::getProxyMode", !RT_VALID_PTR(aProxyMode) ? 0 : *aProxyMode, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(ProxyMode)(ProxyMode_T aProxyMode)
{
    LogRelFlow(("{%p} %s: enter aProxyMode=%RU32\n", this, "SystemProperties::setProxyMode", aProxyMode));

    // Clear 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_SYSTEMPROPERTIES_SET_PROXYMODE_ENTER(this, aProxyMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProxyMode(aProxyMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYMODE_RETURN(this, hrc, 0 /*normal*/,aProxyMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYMODE_RETURN(this, hrc, 1 /*hrc exception*/,aProxyMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aProxyMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setProxyMode", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(ProxyURL)(BSTR *aProxyURL)
{
    LogRelFlow(("{%p} %s: enter aProxyURL=%p\n", this, "SystemProperties::getProxyURL", aProxyURL));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProxyURL);
        BSTROutConverter TmpProxyURL(aProxyURL);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYURL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProxyURL(TmpProxyURL.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYURL_RETURN(this, hrc, 0 /*normal*/,TmpProxyURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_PROXYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProxyURL=%ls hrc=%Rhrc\n", this, "SystemProperties::getProxyURL", !RT_VALID_PTR(aProxyURL) ? 0 : *aProxyURL, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(ProxyURL)(IN_BSTR aProxyURL)
{
    LogRelFlow(("{%p} %s: enter aProxyURL=%ls\n", this, "SystemProperties::setProxyURL", aProxyURL));

    // Clear 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 TmpProxyURL(aProxyURL);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYURL_ENTER(this, TmpProxyURL.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProxyURL(TmpProxyURL.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYURL_RETURN(this, hrc, 0 /*normal*/,TmpProxyURL.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYURL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_PROXYURL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setProxyURL", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedPlatformArchitectures)(ComSafeArrayOut(PlatformArchitecture_T, aSupportedPlatformArchitectures))
{
    LogRelFlow(("{%p} %s: enter aSupportedPlatformArchitectures=%p\n", this, "SystemProperties::getSupportedPlatformArchitectures", aSupportedPlatformArchitectures));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedPlatformArchitectures);
        ArrayOutConverter<PlatformArchitecture_T> TmpSupportedPlatformArchitectures(ComSafeArrayOutArg(aSupportedPlatformArchitectures));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPLATFORMARCHITECTURES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedPlatformArchitectures(TmpSupportedPlatformArchitectures.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPLATFORMARCHITECTURES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedPlatformArchitectures.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPLATFORMARCHITECTURES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPLATFORMARCHITECTURES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedPlatformArchitectures=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedPlatformArchitectures", !RT_VALID_PTR(aSupportedPlatformArchitectures) ? 0 : ComSafeArraySize(*aSupportedPlatformArchitectures), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedClipboardModes)(ComSafeArrayOut(ClipboardMode_T, aSupportedClipboardModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedClipboardModes=%p\n", this, "SystemProperties::getSupportedClipboardModes", aSupportedClipboardModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedClipboardModes);
        ArrayOutConverter<ClipboardMode_T> TmpSupportedClipboardModes(ComSafeArrayOutArg(aSupportedClipboardModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLIPBOARDMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedClipboardModes(TmpSupportedClipboardModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLIPBOARDMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedClipboardModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLIPBOARDMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLIPBOARDMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedClipboardModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedClipboardModes", !RT_VALID_PTR(aSupportedClipboardModes) ? 0 : ComSafeArraySize(*aSupportedClipboardModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedDnDModes)(ComSafeArrayOut(DnDMode_T, aSupportedDnDModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedDnDModes=%p\n", this, "SystemProperties::getSupportedDnDModes", aSupportedDnDModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedDnDModes);
        ArrayOutConverter<DnDMode_T> TmpSupportedDnDModes(ComSafeArrayOutArg(aSupportedDnDModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDDNDMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedDnDModes(TmpSupportedDnDModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDDNDMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedDnDModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDDNDMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDDNDMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedDnDModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedDnDModes", !RT_VALID_PTR(aSupportedDnDModes) ? 0 : ComSafeArraySize(*aSupportedDnDModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedPointingHIDTypes)(ComSafeArrayOut(PointingHIDType_T, aSupportedPointingHIDTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedPointingHIDTypes=%p\n", this, "SystemProperties::getSupportedPointingHIDTypes", aSupportedPointingHIDTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedPointingHIDTypes);
        ArrayOutConverter<PointingHIDType_T> TmpSupportedPointingHIDTypes(ComSafeArrayOutArg(aSupportedPointingHIDTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPOINTINGHIDTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedPointingHIDTypes(TmpSupportedPointingHIDTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPOINTINGHIDTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedPointingHIDTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPOINTINGHIDTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPOINTINGHIDTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedPointingHIDTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedPointingHIDTypes", !RT_VALID_PTR(aSupportedPointingHIDTypes) ? 0 : ComSafeArraySize(*aSupportedPointingHIDTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedKeyboardHIDTypes)(ComSafeArrayOut(KeyboardHIDType_T, aSupportedKeyboardHIDTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedKeyboardHIDTypes=%p\n", this, "SystemProperties::getSupportedKeyboardHIDTypes", aSupportedKeyboardHIDTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedKeyboardHIDTypes);
        ArrayOutConverter<KeyboardHIDType_T> TmpSupportedKeyboardHIDTypes(ComSafeArrayOutArg(aSupportedKeyboardHIDTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDKEYBOARDHIDTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedKeyboardHIDTypes(TmpSupportedKeyboardHIDTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDKEYBOARDHIDTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedKeyboardHIDTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDKEYBOARDHIDTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDKEYBOARDHIDTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedKeyboardHIDTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedKeyboardHIDTypes", !RT_VALID_PTR(aSupportedKeyboardHIDTypes) ? 0 : ComSafeArraySize(*aSupportedKeyboardHIDTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedVFSTypes)(ComSafeArrayOut(VFSType_T, aSupportedVFSTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedVFSTypes=%p\n", this, "SystemProperties::getSupportedVFSTypes", aSupportedVFSTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedVFSTypes);
        ArrayOutConverter<VFSType_T> TmpSupportedVFSTypes(ComSafeArrayOutArg(aSupportedVFSTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVFSTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedVFSTypes(TmpSupportedVFSTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVFSTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedVFSTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVFSTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVFSTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedVFSTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedVFSTypes", !RT_VALID_PTR(aSupportedVFSTypes) ? 0 : ComSafeArraySize(*aSupportedVFSTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedImportOptions)(ComSafeArrayOut(ImportOptions_T, aSupportedImportOptions))
{
    LogRelFlow(("{%p} %s: enter aSupportedImportOptions=%p\n", this, "SystemProperties::getSupportedImportOptions", aSupportedImportOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedImportOptions);
        ArrayOutConverter<ImportOptions_T> TmpSupportedImportOptions(ComSafeArrayOutArg(aSupportedImportOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDIMPORTOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedImportOptions(TmpSupportedImportOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDIMPORTOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedImportOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDIMPORTOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDIMPORTOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedImportOptions=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedImportOptions", !RT_VALID_PTR(aSupportedImportOptions) ? 0 : ComSafeArraySize(*aSupportedImportOptions), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedExportOptions)(ComSafeArrayOut(ExportOptions_T, aSupportedExportOptions))
{
    LogRelFlow(("{%p} %s: enter aSupportedExportOptions=%p\n", this, "SystemProperties::getSupportedExportOptions", aSupportedExportOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedExportOptions);
        ArrayOutConverter<ExportOptions_T> TmpSupportedExportOptions(ComSafeArrayOutArg(aSupportedExportOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDEXPORTOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedExportOptions(TmpSupportedExportOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDEXPORTOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedExportOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDEXPORTOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDEXPORTOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedExportOptions=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedExportOptions", !RT_VALID_PTR(aSupportedExportOptions) ? 0 : ComSafeArraySize(*aSupportedExportOptions), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedGraphicsFeatures)(ComSafeArrayOut(GraphicsFeature_T, aSupportedGraphicsFeatures))
{
    LogRelFlow(("{%p} %s: enter aSupportedGraphicsFeatures=%p\n", this, "SystemProperties::getSupportedGraphicsFeatures", aSupportedGraphicsFeatures));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedGraphicsFeatures);
        ArrayOutConverter<GraphicsFeature_T> TmpSupportedGraphicsFeatures(ComSafeArrayOutArg(aSupportedGraphicsFeatures));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDGRAPHICSFEATURES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedGraphicsFeatures(TmpSupportedGraphicsFeatures.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDGRAPHICSFEATURES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedGraphicsFeatures.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDGRAPHICSFEATURES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDGRAPHICSFEATURES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedGraphicsFeatures=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedGraphicsFeatures", !RT_VALID_PTR(aSupportedGraphicsFeatures) ? 0 : ComSafeArraySize(*aSupportedGraphicsFeatures), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingFeatures)(ComSafeArrayOut(RecordingFeature_T, aSupportedRecordingFeatures))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingFeatures=%p\n", this, "SystemProperties::getSupportedRecordingFeatures", aSupportedRecordingFeatures));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingFeatures);
        ArrayOutConverter<RecordingFeature_T> TmpSupportedRecordingFeatures(ComSafeArrayOutArg(aSupportedRecordingFeatures));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGFEATURES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingFeatures(TmpSupportedRecordingFeatures.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGFEATURES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingFeatures.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGFEATURES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGFEATURES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingFeatures=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingFeatures", !RT_VALID_PTR(aSupportedRecordingFeatures) ? 0 : ComSafeArraySize(*aSupportedRecordingFeatures), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingAudioCodecs)(ComSafeArrayOut(RecordingAudioCodec_T, aSupportedRecordingAudioCodecs))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingAudioCodecs=%p\n", this, "SystemProperties::getSupportedRecordingAudioCodecs", aSupportedRecordingAudioCodecs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingAudioCodecs);
        ArrayOutConverter<RecordingAudioCodec_T> TmpSupportedRecordingAudioCodecs(ComSafeArrayOutArg(aSupportedRecordingAudioCodecs));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGAUDIOCODECS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingAudioCodecs(TmpSupportedRecordingAudioCodecs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGAUDIOCODECS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingAudioCodecs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGAUDIOCODECS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGAUDIOCODECS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingAudioCodecs=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingAudioCodecs", !RT_VALID_PTR(aSupportedRecordingAudioCodecs) ? 0 : ComSafeArraySize(*aSupportedRecordingAudioCodecs), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingVideoCodecs)(ComSafeArrayOut(RecordingVideoCodec_T, aSupportedRecordingVideoCodecs))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingVideoCodecs=%p\n", this, "SystemProperties::getSupportedRecordingVideoCodecs", aSupportedRecordingVideoCodecs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingVideoCodecs);
        ArrayOutConverter<RecordingVideoCodec_T> TmpSupportedRecordingVideoCodecs(ComSafeArrayOutArg(aSupportedRecordingVideoCodecs));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVIDEOCODECS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingVideoCodecs(TmpSupportedRecordingVideoCodecs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVIDEOCODECS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingVideoCodecs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVIDEOCODECS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVIDEOCODECS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingVideoCodecs=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingVideoCodecs", !RT_VALID_PTR(aSupportedRecordingVideoCodecs) ? 0 : ComSafeArraySize(*aSupportedRecordingVideoCodecs), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingVSModes)(ComSafeArrayOut(RecordingVideoScalingMode_T, aSupportedRecordingVSModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingVSModes=%p\n", this, "SystemProperties::getSupportedRecordingVSModes", aSupportedRecordingVSModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingVSModes);
        ArrayOutConverter<RecordingVideoScalingMode_T> TmpSupportedRecordingVSModes(ComSafeArrayOutArg(aSupportedRecordingVSModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVSMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingVSModes(TmpSupportedRecordingVSModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVSMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingVSModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVSMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVSMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingVSModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingVSModes", !RT_VALID_PTR(aSupportedRecordingVSModes) ? 0 : ComSafeArraySize(*aSupportedRecordingVSModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingARCModes)(ComSafeArrayOut(RecordingRateControlMode_T, aSupportedRecordingARCModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingARCModes=%p\n", this, "SystemProperties::getSupportedRecordingARCModes", aSupportedRecordingARCModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingARCModes);
        ArrayOutConverter<RecordingRateControlMode_T> TmpSupportedRecordingARCModes(ComSafeArrayOutArg(aSupportedRecordingARCModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGARCMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingARCModes(TmpSupportedRecordingARCModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGARCMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingARCModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGARCMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGARCMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingARCModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingARCModes", !RT_VALID_PTR(aSupportedRecordingARCModes) ? 0 : ComSafeArraySize(*aSupportedRecordingARCModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedRecordingVRCModes)(ComSafeArrayOut(RecordingRateControlMode_T, aSupportedRecordingVRCModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedRecordingVRCModes=%p\n", this, "SystemProperties::getSupportedRecordingVRCModes", aSupportedRecordingVRCModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedRecordingVRCModes);
        ArrayOutConverter<RecordingRateControlMode_T> TmpSupportedRecordingVRCModes(ComSafeArrayOutArg(aSupportedRecordingVRCModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVRCMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedRecordingVRCModes(TmpSupportedRecordingVRCModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVRCMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedRecordingVRCModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVRCMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDRECORDINGVRCMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedRecordingVRCModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedRecordingVRCModes", !RT_VALID_PTR(aSupportedRecordingVRCModes) ? 0 : ComSafeArraySize(*aSupportedRecordingVRCModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedCloneOptions)(ComSafeArrayOut(CloneOptions_T, aSupportedCloneOptions))
{
    LogRelFlow(("{%p} %s: enter aSupportedCloneOptions=%p\n", this, "SystemProperties::getSupportedCloneOptions", aSupportedCloneOptions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedCloneOptions);
        ArrayOutConverter<CloneOptions_T> TmpSupportedCloneOptions(ComSafeArrayOutArg(aSupportedCloneOptions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLONEOPTIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedCloneOptions(TmpSupportedCloneOptions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLONEOPTIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedCloneOptions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLONEOPTIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDCLONEOPTIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedCloneOptions=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedCloneOptions", !RT_VALID_PTR(aSupportedCloneOptions) ? 0 : ComSafeArraySize(*aSupportedCloneOptions), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedAutostopTypes)(ComSafeArrayOut(AutostopType_T, aSupportedAutostopTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedAutostopTypes=%p\n", this, "SystemProperties::getSupportedAutostopTypes", aSupportedAutostopTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedAutostopTypes);
        ArrayOutConverter<AutostopType_T> TmpSupportedAutostopTypes(ComSafeArrayOutArg(aSupportedAutostopTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUTOSTOPTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedAutostopTypes(TmpSupportedAutostopTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUTOSTOPTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedAutostopTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUTOSTOPTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUTOSTOPTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedAutostopTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedAutostopTypes", !RT_VALID_PTR(aSupportedAutostopTypes) ? 0 : ComSafeArraySize(*aSupportedAutostopTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedVMProcPriorities)(ComSafeArrayOut(VMProcPriority_T, aSupportedVMProcPriorities))
{
    LogRelFlow(("{%p} %s: enter aSupportedVMProcPriorities=%p\n", this, "SystemProperties::getSupportedVMProcPriorities", aSupportedVMProcPriorities));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedVMProcPriorities);
        ArrayOutConverter<VMProcPriority_T> TmpSupportedVMProcPriorities(ComSafeArrayOutArg(aSupportedVMProcPriorities));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVMPROCPRIORITIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedVMProcPriorities(TmpSupportedVMProcPriorities.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVMPROCPRIORITIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedVMProcPriorities.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVMPROCPRIORITIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDVMPROCPRIORITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedVMProcPriorities=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedVMProcPriorities", !RT_VALID_PTR(aSupportedVMProcPriorities) ? 0 : ComSafeArraySize(*aSupportedVMProcPriorities), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedNetworkAttachmentTypes)(ComSafeArrayOut(NetworkAttachmentType_T, aSupportedNetworkAttachmentTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedNetworkAttachmentTypes=%p\n", this, "SystemProperties::getSupportedNetworkAttachmentTypes", aSupportedNetworkAttachmentTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedNetworkAttachmentTypes);
        ArrayOutConverter<NetworkAttachmentType_T> TmpSupportedNetworkAttachmentTypes(ComSafeArrayOutArg(aSupportedNetworkAttachmentTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDNETWORKATTACHMENTTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedNetworkAttachmentTypes(TmpSupportedNetworkAttachmentTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDNETWORKATTACHMENTTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedNetworkAttachmentTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDNETWORKATTACHMENTTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDNETWORKATTACHMENTTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedNetworkAttachmentTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedNetworkAttachmentTypes", !RT_VALID_PTR(aSupportedNetworkAttachmentTypes) ? 0 : ComSafeArraySize(*aSupportedNetworkAttachmentTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedPortModes)(ComSafeArrayOut(PortMode_T, aSupportedPortModes))
{
    LogRelFlow(("{%p} %s: enter aSupportedPortModes=%p\n", this, "SystemProperties::getSupportedPortModes", aSupportedPortModes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedPortModes);
        ArrayOutConverter<PortMode_T> TmpSupportedPortModes(ComSafeArrayOutArg(aSupportedPortModes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPORTMODES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedPortModes(TmpSupportedPortModes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPORTMODES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedPortModes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPORTMODES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDPORTMODES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedPortModes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedPortModes", !RT_VALID_PTR(aSupportedPortModes) ? 0 : ComSafeArraySize(*aSupportedPortModes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(SupportedAudioDriverTypes)(ComSafeArrayOut(AudioDriverType_T, aSupportedAudioDriverTypes))
{
    LogRelFlow(("{%p} %s: enter aSupportedAudioDriverTypes=%p\n", this, "SystemProperties::getSupportedAudioDriverTypes", aSupportedAudioDriverTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedAudioDriverTypes);
        ArrayOutConverter<AudioDriverType_T> TmpSupportedAudioDriverTypes(ComSafeArrayOutArg(aSupportedAudioDriverTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUDIODRIVERTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedAudioDriverTypes(TmpSupportedAudioDriverTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUDIODRIVERTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedAudioDriverTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUDIODRIVERTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_SUPPORTEDAUDIODRIVERTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedAudioDriverTypes=%zu hrc=%Rhrc\n", this, "SystemProperties::getSupportedAudioDriverTypes", !RT_VALID_PTR(aSupportedAudioDriverTypes) ? 0 : ComSafeArraySize(*aSupportedAudioDriverTypes), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(LanguageId)(BSTR *aLanguageId)
{
    LogRelFlow(("{%p} %s: enter aLanguageId=%p\n", this, "SystemProperties::getLanguageId", aLanguageId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLanguageId);
        BSTROutConverter TmpLanguageId(aLanguageId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LANGUAGEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLanguageId(TmpLanguageId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LANGUAGEID_RETURN(this, hrc, 0 /*normal*/,TmpLanguageId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LANGUAGEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GET_LANGUAGEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLanguageId=%ls hrc=%Rhrc\n", this, "SystemProperties::getLanguageId", !RT_VALID_PTR(aLanguageId) ? 0 : *aLanguageId, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMSETTER(LanguageId)(IN_BSTR aLanguageId)
{
    LogRelFlow(("{%p} %s: enter aLanguageId=%ls\n", this, "SystemProperties::setLanguageId", aLanguageId));

    // Clear 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 TmpLanguageId(aLanguageId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LANGUAGEID_ENTER(this, TmpLanguageId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLanguageId(TmpLanguageId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LANGUAGEID_RETURN(this, hrc, 0 /*normal*/,TmpLanguageId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LANGUAGEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_SET_LANGUAGEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SystemProperties::setLanguageId", hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute1ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute2ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute3ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute4ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute5ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute6ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute7ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute8ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute9ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute10ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute11ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute12ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute13ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute14ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute15ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::COMGETTER(InternalAndReservedAttribute16ISystemProperties)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISystemProperties methods
//

STDMETHODIMP SystemPropertiesWrap::GetDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
                                                                                BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%RU32 aEnabled=%p\n", this, "SystemProperties::getDefaultIoCacheSettingForStorageController", aControllerType, 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_SYSTEMPROPERTIES_GETDEFAULTSTORAGECTRLCACHESETTING_ENTER(this, aControllerType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultIoCacheSettingForStorageController(aControllerType,
                                                               aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETDEFAULTSTORAGECTRLCACHESETTING_RETURN(this, hrc, 0 /*normal*/, aControllerType, *aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETDEFAULTSTORAGECTRLCACHESETTING_RETURN(this, hrc, 1 /*hrc exception*/, aControllerType, *aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETDEFAULTSTORAGECTRLCACHESETTING_RETURN(this, hrc, 9 /*unhandled exception*/, aControllerType, *aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aEnabled=%RTbool hrc=%Rhrc\n", this, "SystemProperties::getDefaultIoCacheSettingForStorageController", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::GetCPUProfiles(CPUArchitecture_T aArchitecture,
                                                  IN_BSTR aNamePattern,
                                                  ComSafeArrayOut(ICPUProfile *, aProfiles))
{
    LogRelFlow(("{%p} %s: enter aArchitecture=%RU32 aNamePattern=%ls aProfiles=%p\n", this, "SystemProperties::getCPUProfiles", aArchitecture, aNamePattern, aProfiles));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProfiles);


        
        BSTRInConverter TmpNamePattern(aNamePattern);
        ArrayComTypeOutConverter<ICPUProfile> TmpProfiles(ComSafeArrayOutArg(aProfiles));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETCPUPROFILES_ENTER(this, aArchitecture, TmpNamePattern.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCPUProfiles(aArchitecture,
                                 TmpNamePattern.str(),
                                 TmpProfiles.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETCPUPROFILES_RETURN(this, hrc, 0 /*normal*/, aArchitecture, TmpNamePattern.str().c_str(), (uint32_t)TmpProfiles.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETCPUPROFILES_RETURN(this, hrc, 1 /*hrc exception*/, aArchitecture, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETCPUPROFILES_RETURN(this, hrc, 9 /*unhandled exception*/, aArchitecture, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProfiles=%zu hrc=%Rhrc\n", this, "SystemProperties::getCPUProfiles", !RT_VALID_PTR(aProfiles) ? 0 : ComSafeArraySize(*aProfiles), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::GetExecutionEnginesForVmCpuArchitecture(CPUArchitecture_T aCpuArchitecture,
                                                                           ComSafeArrayOut(VMExecutionEngine_T, aExecutionEngine))
{
    LogRelFlow(("{%p} %s: enter aCpuArchitecture=%RU32 aExecutionEngine=%p\n", this, "SystemProperties::getExecutionEnginesForVmCpuArchitecture", aCpuArchitecture, 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);


        
        ArrayOutConverter<VMExecutionEngine_T> TmpExecutionEngine(ComSafeArrayOutArg(aExecutionEngine));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETEXECUTIONENGINESFORVMCPUARCHITECTURE_ENTER(this, aCpuArchitecture);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExecutionEnginesForVmCpuArchitecture(aCpuArchitecture,
                                                          TmpExecutionEngine.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETEXECUTIONENGINESFORVMCPUARCHITECTURE_RETURN(this, hrc, 0 /*normal*/, aCpuArchitecture, (uint32_t)TmpExecutionEngine.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETEXECUTIONENGINESFORVMCPUARCHITECTURE_RETURN(this, hrc, 1 /*hrc exception*/, aCpuArchitecture, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SYSTEMPROPERTIES_GETEXECUTIONENGINESFORVMCPUARCHITECTURE_RETURN(this, hrc, 9 /*unhandled exception*/, aCpuArchitecture, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExecutionEngine=%zu hrc=%Rhrc\n", this, "SystemProperties::getExecutionEnginesForVmCpuArchitecture", !RT_VALID_PTR(aExecutionEngine) ? 0 : ComSafeArraySize(*aExecutionEngine), hrc));
    return hrc;
}

STDMETHODIMP SystemPropertiesWrap::InternalAndReservedMethod1ISystemProperties()
{
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::InternalAndReservedMethod2ISystemProperties()
{
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::InternalAndReservedMethod3ISystemProperties()
{
    return E_NOTIMPL;
}

STDMETHODIMP SystemPropertiesWrap::InternalAndReservedMethod4ISystemProperties()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SystemPropertiesWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SystemPropertiesWrap, ISystemProperties)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SystemPropertiesWrap.cpp"


// ##### BEGINFILE "DnDBaseWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDnDBase.
 *
 * 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_DNDBASE

#include "DnDBaseWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DnDBaseWrap)

//
// IDnDBase properties
//

STDMETHODIMP DnDBaseWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "DnDBase::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_DNDBASE_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_DNDBASE_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_DNDBASE_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_DNDBASE_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "DnDBase::getFormats", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP DnDBaseWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDBaseWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDnDBase methods
//

STDMETHODIMP DnDBaseWrap::IsFormatSupported(IN_BSTR aFormat,
                                            BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aSupported=%p\n", this, "DnDBase::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_DNDBASE_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_DNDBASE_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_DNDBASE_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_DNDBASE_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "DnDBase::isFormatSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP DnDBaseWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDBase::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_DNDBASE_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_DNDBASE_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_DNDBASE_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_DNDBASE_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDBase::addFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDBaseWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "DnDBase::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_DNDBASE_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_DNDBASE_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_DNDBASE_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_DNDBASE_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDBase::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDBaseWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DnDBaseWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DnDBaseWrap, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DnDBaseWrap.cpp"


// ##### BEGINFILE "GuestDnDSourceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDnDSource.
 *
 * 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_GUESTDNDSOURCE

#include "GuestDnDSourceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDnDSourceWrap)

//
// IDnDBase properties
//

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "GuestDnDSource::getFormats", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDSource properties
//

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestDnDSource properties
//

STDMETHODIMP GuestDnDSourceWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestDnDSource::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, "GuestDnDSource::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IDnDBase methods
//

STDMETHODIMP GuestDnDSourceWrap::IsFormatSupported(IN_BSTR aFormat,
                                                   BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aSupported=%p\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "GuestDnDSource::isFormatSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDnDSource::addFormats", hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDnDSource::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDSource methods
//

STDMETHODIMP GuestDnDSourceWrap::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, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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, "GuestDnDSource::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 GuestDnDSourceWrap::Drop(IN_BSTR aFormat,
                                      DnDAction_T aAction,
                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aAction=%RU32 aProgress=%p\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_DROP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAction, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestDnDSource::drop", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::ReceiveData(ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aData=%p\n", this, "GuestDnDSource::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_GUESTDNDSOURCE_RECEIVEDATA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = receiveData(TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDSOURCE_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_GUESTDNDSOURCE_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_GUESTDNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestDnDSource::receiveData", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestDnDSourceWrap::InternalAndReservedMethod1IDnDSource()
{
    return E_NOTIMPL;
}

//
// IGuestDnDSource methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDnDSourceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(GuestDnDSourceWrap, IGuestDnDSource, IDnDSource, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDnDSourceWrap.cpp"


// ##### BEGINFILE "GuestDnDTargetWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDnDTarget.
 *
 * 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_GUESTDNDTARGET

#include "GuestDnDTargetWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDnDTargetWrap)

//
// IDnDBase properties
//

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "GuestDnDTarget::getFormats", !RT_VALID_PTR(aFormats) ? 0 : ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDTarget properties
//

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestDnDTarget properties
//

STDMETHODIMP GuestDnDTargetWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestDnDTarget::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, "GuestDnDTarget::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IDnDBase methods
//

STDMETHODIMP GuestDnDTargetWrap::IsFormatSupported(IN_BSTR aFormat,
                                                   BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aFormat=%ls aSupported=%p\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "GuestDnDTarget::isFormatSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDnDTarget::addFormats", hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%zu\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDnDTarget::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDTarget methods
//

STDMETHODIMP GuestDnDTargetWrap::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, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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, "GuestDnDTarget::enter", !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::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, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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, "GuestDnDTarget::move", !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::Leave(ULONG aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_LEAVE_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = leave(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDTARGET_LEAVE_RETURN(this, hrc, 0 /*normal*/, aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDTARGET_LEAVE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDTARGET_LEAVE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDnDTarget::leave", hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::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, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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, "GuestDnDTarget::drop", !RT_VALID_PTR(aFormat) ? 0 : *aFormat, !RT_VALID_PTR(aResultAction) ? 0 : *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::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, "GuestDnDTarget::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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_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_GUESTDNDTARGET_SENDDATA_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestDnDTarget::sendData", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::Cancel(BOOL *aVeto)
{
    LogRelFlow(("{%p} %s: enter aVeto=%p\n", this, "GuestDnDTarget::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_GUESTDNDTARGET_CANCEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancel(aVeto);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDTARGET_CANCEL_RETURN(this, hrc, 0 /*normal*/, *aVeto != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDNDTARGET_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_GUESTDNDTARGET_CANCEL_RETURN(this, hrc, 9 /*unhandled exception*/, *aVeto != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aVeto=%RTbool hrc=%Rhrc\n", this, "GuestDnDTarget::cancel", !RT_VALID_PTR(aVeto) ? 0 : *aVeto, hrc));
    return hrc;
}

STDMETHODIMP GuestDnDTargetWrap::InternalAndReservedMethod1IDnDTarget()
{
    return E_NOTIMPL;
}

//
// IGuestDnDTarget methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDnDTargetWrap)
NS_IMPL_THREADSAFE_ISUPPORTS3_CI(GuestDnDTargetWrap, IGuestDnDTarget, IDnDTarget, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDnDTargetWrap.cpp"


// ##### BEGINFILE "ProcessWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IProcess.
 *
 * 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_PROCESS

#include "ProcessWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ProcessWrap)

//
// IProcess properties
//

STDMETHODIMP ProcessWrap::COMGETTER(Arguments)(ComSafeArrayOut(BSTR, aArguments))
{
    LogRelFlow(("{%p} %s: enter aArguments=%p\n", this, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_GET_ARGUMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aArguments=%zu hrc=%Rhrc\n", this, "Process::getArguments", !RT_VALID_PTR(aArguments) ? 0 : ComSafeArraySize(*aArguments), hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))
{
    LogRelFlow(("{%p} %s: enter aEnvironment=%p\n", this, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironment=%zu hrc=%Rhrc\n", this, "Process::getEnvironment", !RT_VALID_PTR(aEnvironment) ? 0 : ComSafeArraySize(*aEnvironment), hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Process::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_PROCESS_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_PROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Process::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(ExecutablePath)(BSTR *aExecutablePath)
{
    LogRelFlow(("{%p} %s: enter aExecutablePath=%p\n", this, "Process::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_PROCESS_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_PROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 0 /*normal*/,TmpExecutablePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExecutablePath=%ls hrc=%Rhrc\n", this, "Process::getExecutablePath", !RT_VALID_PTR(aExecutablePath) ? 0 : *aExecutablePath, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(ExitCode)(LONG *aExitCode)
{
    LogRelFlow(("{%p} %s: enter aExitCode=%p\n", this, "Process::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_PROCESS_GET_EXITCODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExitCode(aExitCode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_GET_EXITCODE_RETURN(this, hrc, 0 /*normal*/,*aExitCode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_EXITCODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aExitCode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExitCode=%RI32 hrc=%Rhrc\n", this, "Process::getExitCode", !RT_VALID_PTR(aExitCode) ? 0 : *aExitCode, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Process::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_PROCESS_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_PROCESS_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Process::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(PID)(ULONG *aPID)
{
    LogRelFlow(("{%p} %s: enter aPID=%p\n", this, "Process::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_PROCESS_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPID(aPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPID=%RU32 hrc=%Rhrc\n", this, "Process::getPID", !RT_VALID_PTR(aPID) ? 0 : *aPID, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(Status)(ProcessStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "Process::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_PROCESS_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "Process::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute1IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute2IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute3IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute4IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute5IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute6IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute7IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::COMGETTER(InternalAndReservedAttribute8IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IProcess methods
//

STDMETHODIMP ProcessWrap::WaitFor(ULONG aWaitFor,
                                  ULONG aTimeoutMS,
                                  ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%RU32 aTimeoutMS=%RU32 aReason=%p\n", this, "Process::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_PROCESS_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_PROCESS_WAITFOR_RETURN(this, hrc, 0 /*normal*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_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_PROCESS_WAITFOR_RETURN(this, hrc, 9 /*unhandled exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "Process::waitFor", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::WaitForArray(ComSafeArrayIn(ProcessWaitForFlag_T, aWaitFor),
                                       ULONG aTimeoutMS,
                                       ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s: enter aWaitFor=%zu aTimeoutMS=%RU32 aReason=%p\n", this, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_WAITFORARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "Process::waitForArray", !RT_VALID_PTR(aReason) ? 0 : *aReason, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::Read(ULONG aHandle,
                               ULONG aToRead,
                               ULONG aTimeoutMS,
                               ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aHandle=%RU32 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "Process::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::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, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aFlags, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "Process::write", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::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, "Process::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_PROCESS_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_PROCESS_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_PROCESS_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_PROCESS_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, "Process::writeArray", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::Terminate()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Process::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_PROCESS_TERMINATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = terminate();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_TERMINATE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_TERMINATE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROCESS_TERMINATE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Process::terminate", hrc));
    return hrc;
}

STDMETHODIMP ProcessWrap::InternalAndReservedMethod1IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::InternalAndReservedMethod2IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::InternalAndReservedMethod3IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProcessWrap::InternalAndReservedMethod4IProcess()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ProcessWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ProcessWrap, IProcess)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ProcessWrap.cpp"


// ##### BEGINFILE "DirectoryWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDirectory.
 *
 * 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_DIRECTORY

#include "DirectoryWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DirectoryWrap)

//
// IDirectory properties
//

STDMETHODIMP DirectoryWrap::COMGETTER(DirectoryName)(BSTR *aDirectoryName)
{
    LogRelFlow(("{%p} %s: enter aDirectoryName=%p\n", this, "Directory::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_DIRECTORY_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_DIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 0 /*normal*/,TmpDirectoryName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_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_DIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectoryName=%ls hrc=%Rhrc\n", this, "Directory::getDirectoryName", !RT_VALID_PTR(aDirectoryName) ? 0 : *aDirectoryName, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Directory::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_DIRECTORY_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_DIRECTORY_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_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_DIRECTORY_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Directory::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::COMGETTER(Filter)(BSTR *aFilter)
{
    LogRelFlow(("{%p} %s: enter aFilter=%p\n", this, "Directory::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_DIRECTORY_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_DIRECTORY_GET_FILTER_RETURN(this, hrc, 0 /*normal*/,TmpFilter.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_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_DIRECTORY_GET_FILTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilter=%ls hrc=%Rhrc\n", this, "Directory::getFilter", !RT_VALID_PTR(aFilter) ? 0 : *aFilter, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Directory::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_DIRECTORY_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_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_DIRECTORY_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "Directory::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::COMGETTER(Status)(DirectoryStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "Directory::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_DIRECTORY_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_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_DIRECTORY_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "Directory::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute1IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute2IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute3IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute4IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute5IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute6IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute7IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::COMGETTER(InternalAndReservedAttribute8IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDirectory methods
//

STDMETHODIMP DirectoryWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Directory::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_DIRECTORY_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Directory::close", hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::List(ULONG aMaxEntries,
                                 ComSafeArrayOut(IFsObjInfo *, aObjInfo))
{
    LogRelFlow(("{%p} %s: enter aMaxEntries=%RU32 aObjInfo=%p\n", this, "Directory::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_DIRECTORY_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_DIRECTORY_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_DIRECTORY_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_DIRECTORY_LIST_RETURN(this, hrc, 9 /*unhandled exception*/, aMaxEntries, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%zu hrc=%Rhrc\n", this, "Directory::list", !RT_VALID_PTR(aObjInfo) ? 0 : ComSafeArraySize(*aObjInfo), hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::Read(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s: enter aObjInfo=%p\n", this, "Directory::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_DIRECTORY_READ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_READ_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_READ_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_READ_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "Directory::read", !RT_VALID_PTR(aObjInfo) ? 0 : *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::Rewind()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Directory::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_DIRECTORY_REWIND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = rewind();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_REWIND_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_REWIND_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DIRECTORY_REWIND_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Directory::rewind", hrc));
    return hrc;
}

STDMETHODIMP DirectoryWrap::InternalAndReservedMethod1IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::InternalAndReservedMethod2IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::InternalAndReservedMethod3IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP DirectoryWrap::InternalAndReservedMethod4IDirectory()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DirectoryWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DirectoryWrap, IDirectory)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DirectoryWrap.cpp"


// ##### BEGINFILE "FileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFile.
 *
 * 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_FILE

#include "FileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FileWrap)

//
// IFile properties
//

STDMETHODIMP FileWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "File::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_FILE_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_FILE_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "File::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "File::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_FILE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "File::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(InitialSize)(LONG64 *aInitialSize)
{
    LogRelFlow(("{%p} %s: enter aInitialSize=%p\n", this, "File::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_FILE_GET_INITIALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInitialSize(aInitialSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_INITIALSIZE_RETURN(this, hrc, 0 /*normal*/,*aInitialSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_INITIALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInitialSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInitialSize=%RI64 hrc=%Rhrc\n", this, "File::getInitialSize", !RT_VALID_PTR(aInitialSize) ? 0 : *aInitialSize, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(Offset)(LONG64 *aOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%p\n", this, "File::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_FILE_GET_OFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOffset(aOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_OFFSET_RETURN(this, hrc, 0 /*normal*/,*aOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_OFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOffset=%RI64 hrc=%Rhrc\n", this, "File::getOffset", !RT_VALID_PTR(aOffset) ? 0 : *aOffset, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(Status)(FileStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "File::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_FILE_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "File::getStatus", !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(Filename)(BSTR *aFilename)
{
    LogRelFlow(("{%p} %s: enter aFilename=%p\n", this, "File::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_FILE_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_FILE_GET_FILENAME_RETURN(this, hrc, 0 /*normal*/,TmpFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_FILENAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilename=%ls hrc=%Rhrc\n", this, "File::getFilename", !RT_VALID_PTR(aFilename) ? 0 : *aFilename, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(CreationMode)(ULONG *aCreationMode)
{
    LogRelFlow(("{%p} %s: enter aCreationMode=%p\n", this, "File::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_FILE_GET_CREATIONMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCreationMode(aCreationMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_CREATIONMODE_RETURN(this, hrc, 0 /*normal*/,*aCreationMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_CREATIONMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aCreationMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCreationMode=%RU32 hrc=%Rhrc\n", this, "File::getCreationMode", !RT_VALID_PTR(aCreationMode) ? 0 : *aCreationMode, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(OpenAction)(FileOpenAction_T *aOpenAction)
{
    LogRelFlow(("{%p} %s: enter aOpenAction=%p\n", this, "File::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_FILE_GET_OPENACTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOpenAction(aOpenAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_OPENACTION_RETURN(this, hrc, 0 /*normal*/,*aOpenAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_OPENACTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aOpenAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOpenAction=%RU32 hrc=%Rhrc\n", this, "File::getOpenAction", !RT_VALID_PTR(aOpenAction) ? 0 : *aOpenAction, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(AccessMode)(FileAccessMode_T *aAccessMode)
{
    LogRelFlow(("{%p} %s: enter aAccessMode=%p\n", this, "File::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_FILE_GET_ACCESSMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessMode(aAccessMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_GET_ACCESSMODE_RETURN(this, hrc, 0 /*normal*/,*aAccessMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_GET_ACCESSMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessMode=%RU32 hrc=%Rhrc\n", this, "File::getAccessMode", !RT_VALID_PTR(aAccessMode) ? 0 : *aAccessMode, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute1IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute2IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute3IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute4IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute5IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute6IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute7IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::COMGETTER(InternalAndReservedAttribute8IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFile methods
//

STDMETHODIMP FileWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "File::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_FILE_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "File::close", hrc));
    return hrc;
}

STDMETHODIMP FileWrap::QueryInfo(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s: enter aObjInfo=%p\n", this, "File::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_FILE_QUERYINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryInfo(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYINFO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "File::queryInfo", !RT_VALID_PTR(aObjInfo) ? 0 : *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::QuerySize(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%p\n", this, "File::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_FILE_QUERYSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYSIZE_RETURN(this, hrc, 0 /*normal*/, *aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYSIZE_RETURN(this, hrc, 1 /*hrc exception*/, *aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_QUERYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, *aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSize=%RI64 hrc=%Rhrc\n", this, "File::querySize", !RT_VALID_PTR(aSize) ? 0 : *aSize, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::Read(ULONG aToRead,
                            ULONG aTimeoutMS,
                            ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "File::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_FILE_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_FILE_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_FILE_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_FILE_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "File::read", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP FileWrap::ReadAt(LONG64 aOffset,
                              ULONG aToRead,
                              ULONG aTimeoutMS,
                              ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "File::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_FILE_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_FILE_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_FILE_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_FILE_READAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "File::readAt", !RT_VALID_PTR(aData) ? 0 : ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP FileWrap::Seek(LONG64 aOffset,
                            FileSeekOrigin_T aWhence,
                            LONG64 *aNewOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aWhence=%RU32 aNewOffset=%p\n", this, "File::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_FILE_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_FILE_SEEK_RETURN(this, hrc, 0 /*normal*/, aOffset, aWhence, *aNewOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_SEEK_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aWhence, *aNewOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNewOffset=%RI64 hrc=%Rhrc\n", this, "File::seek", !RT_VALID_PTR(aNewOffset) ? 0 : *aNewOffset, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::SetACL(IN_BSTR aAcl,
                              ULONG aMode)
{
    LogRelFlow(("{%p} %s: enter aAcl=%ls aMode=%RU32\n", this, "File::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_FILE_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_FILE_SETACL_RETURN(this, hrc, 0 /*normal*/, TmpAcl.str().c_str(), aMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_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_FILE_SETACL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "File::setACL", hrc));
    return hrc;
}

STDMETHODIMP FileWrap::SetSize(LONG64 aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%RI64\n", this, "File::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_FILE_SETSIZE_ENTER(this, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_SETSIZE_RETURN(this, hrc, 0 /*normal*/, aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_SETSIZE_RETURN(this, hrc, 1 /*hrc exception*/, aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FILE_SETSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "File::setSize", hrc));
    return hrc;
}

STDMETHODIMP FileWrap::Write(ComSafeArrayIn(BYTE, aData),
                             ULONG aTimeoutMS,
                             ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "File::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_FILE_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_FILE_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_FILE_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_FILE_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "File::write", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::WriteAt(LONG64 aOffset,
                               ComSafeArrayIn(BYTE, aData),
                               ULONG aTimeoutMS,
                               ULONG *aWritten)
{
    LogRelFlow(("{%p} %s: enter aOffset=%RI64 aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "File::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_FILE_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_FILE_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_FILE_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_FILE_WRITEAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "File::writeAt", !RT_VALID_PTR(aWritten) ? 0 : *aWritten, hrc));
    return hrc;
}

STDMETHODIMP FileWrap::InternalAndReservedMethod1IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::InternalAndReservedMethod2IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::InternalAndReservedMethod3IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP FileWrap::InternalAndReservedMethod4IFile()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FileWrap, IFile)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FileWrap.cpp"


// ##### BEGINFILE "FsInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFsInfo.
 *
 * 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_FSINFO

#include "FsInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FsInfoWrap)

//
// IFsInfo properties
//

STDMETHODIMP FsInfoWrap::COMGETTER(FreeSize)(LONG64 *aFreeSize)
{
    LogRelFlow(("{%p} %s: enter aFreeSize=%p\n", this, "FsInfo::getFreeSize", aFreeSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_FREESIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeSize(aFreeSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_FREESIZE_RETURN(this, hrc, 0 /*normal*/,*aFreeSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_FREESIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_FREESIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeSize=%RI64 hrc=%Rhrc\n", this, "FsInfo::getFreeSize", !RT_VALID_PTR(aFreeSize) ? 0 : *aFreeSize, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(TotalSize)(LONG64 *aTotalSize)
{
    LogRelFlow(("{%p} %s: enter aTotalSize=%p\n", this, "FsInfo::getTotalSize", aTotalSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTotalSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TOTALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTotalSize(aTotalSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TOTALSIZE_RETURN(this, hrc, 0 /*normal*/,*aTotalSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TOTALSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aTotalSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TOTALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aTotalSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTotalSize=%RI64 hrc=%Rhrc\n", this, "FsInfo::getTotalSize", !RT_VALID_PTR(aTotalSize) ? 0 : *aTotalSize, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(BlockSize)(ULONG *aBlockSize)
{
    LogRelFlow(("{%p} %s: enter aBlockSize=%p\n", this, "FsInfo::getBlockSize", aBlockSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBlockSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_BLOCKSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBlockSize(aBlockSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 0 /*normal*/,*aBlockSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aBlockSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBlockSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBlockSize=%RU32 hrc=%Rhrc\n", this, "FsInfo::getBlockSize", !RT_VALID_PTR(aBlockSize) ? 0 : *aBlockSize, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(SectorSize)(ULONG *aSectorSize)
{
    LogRelFlow(("{%p} %s: enter aSectorSize=%p\n", this, "FsInfo::getSectorSize", aSectorSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSectorSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SECTORSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSectorSize(aSectorSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SECTORSIZE_RETURN(this, hrc, 0 /*normal*/,*aSectorSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SECTORSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aSectorSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SECTORSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSectorSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSectorSize=%RU32 hrc=%Rhrc\n", this, "FsInfo::getSectorSize", !RT_VALID_PTR(aSectorSize) ? 0 : *aSectorSize, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(SerialNumber)(ULONG *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "FsInfo::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);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(aSerialNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,*aSerialNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aSerialNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aSerialNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%RU32 hrc=%Rhrc\n", this, "FsInfo::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(IsRemote)(BOOL *aIsRemote)
{
    LogRelFlow(("{%p} %s: enter aIsRemote=%p\n", this, "FsInfo::getIsRemote", aIsRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsRemote);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsRemote(aIsRemote);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREMOTE_RETURN(this, hrc, 0 /*normal*/,*aIsRemote != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREMOTE_RETURN(this, hrc, 1 /*hrc exception*/,*aIsRemote != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsRemote != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsRemote=%RTbool hrc=%Rhrc\n", this, "FsInfo::getIsRemote", !RT_VALID_PTR(aIsRemote) ? 0 : *aIsRemote, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(IsCaseSensitive)(BOOL *aIsCaseSensitive)
{
    LogRelFlow(("{%p} %s: enter aIsCaseSensitive=%p\n", this, "FsInfo::getIsCaseSensitive", aIsCaseSensitive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsCaseSensitive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCASESENSITIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCaseSensitive(aIsCaseSensitive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 0 /*normal*/,*aIsCaseSensitive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aIsCaseSensitive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCaseSensitive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsCaseSensitive=%RTbool hrc=%Rhrc\n", this, "FsInfo::getIsCaseSensitive", !RT_VALID_PTR(aIsCaseSensitive) ? 0 : *aIsCaseSensitive, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(IsReadOnly)(BOOL *aIsReadOnly)
{
    LogRelFlow(("{%p} %s: enter aIsReadOnly=%p\n", this, "FsInfo::getIsReadOnly", aIsReadOnly));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsReadOnly);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREADONLY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsReadOnly(aIsReadOnly);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREADONLY_RETURN(this, hrc, 0 /*normal*/,*aIsReadOnly != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREADONLY_RETURN(this, hrc, 1 /*hrc exception*/,*aIsReadOnly != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISREADONLY_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsReadOnly != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsReadOnly=%RTbool hrc=%Rhrc\n", this, "FsInfo::getIsReadOnly", !RT_VALID_PTR(aIsReadOnly) ? 0 : *aIsReadOnly, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(IsCompressed)(BOOL *aIsCompressed)
{
    LogRelFlow(("{%p} %s: enter aIsCompressed=%p\n", this, "FsInfo::getIsCompressed", aIsCompressed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsCompressed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCOMPRESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCompressed(aIsCompressed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 0 /*normal*/,*aIsCompressed != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 1 /*hrc exception*/,*aIsCompressed != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCompressed != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsCompressed=%RTbool hrc=%Rhrc\n", this, "FsInfo::getIsCompressed", !RT_VALID_PTR(aIsCompressed) ? 0 : *aIsCompressed, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(SupportsFileCompression)(BOOL *aSupportsFileCompression)
{
    LogRelFlow(("{%p} %s: enter aSupportsFileCompression=%p\n", this, "FsInfo::getSupportsFileCompression", aSupportsFileCompression));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportsFileCompression);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SUPPORTSFILECOMPRESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportsFileCompression(aSupportsFileCompression);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 0 /*normal*/,*aSupportsFileCompression != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 1 /*hrc exception*/,*aSupportsFileCompression != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aSupportsFileCompression != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportsFileCompression=%RTbool hrc=%Rhrc\n", this, "FsInfo::getSupportsFileCompression", !RT_VALID_PTR(aSupportsFileCompression) ? 0 : *aSupportsFileCompression, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(MaxComponent)(ULONG *aMaxComponent)
{
    LogRelFlow(("{%p} %s: enter aMaxComponent=%p\n", this, "FsInfo::getMaxComponent", aMaxComponent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxComponent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MAXCOMPONENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxComponent(aMaxComponent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 0 /*normal*/,*aMaxComponent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxComponent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxComponent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxComponent=%RU32 hrc=%Rhrc\n", this, "FsInfo::getMaxComponent", !RT_VALID_PTR(aMaxComponent) ? 0 : *aMaxComponent, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(Type)(BSTR *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "FsInfo::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);
        BSTROutConverter TmpType(aType);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(TmpType.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,TmpType.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%ls hrc=%Rhrc\n", this, "FsInfo::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "FsInfo::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_FSINFO_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_FSINFO_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_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_FSINFO_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "FsInfo::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(MountPoint)(BSTR *aMountPoint)
{
    LogRelFlow(("{%p} %s: enter aMountPoint=%p\n", this, "FsInfo::getMountPoint", aMountPoint));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMountPoint);
        BSTROutConverter TmpMountPoint(aMountPoint);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MOUNTPOINT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMountPoint(TmpMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 0 /*normal*/,TmpMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMountPoint=%ls hrc=%Rhrc\n", this, "FsInfo::getMountPoint", !RT_VALID_PTR(aMountPoint) ? 0 : *aMountPoint, hrc));
    return hrc;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute1IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute2IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute3IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute4IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute5IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute6IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute7IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FsInfoWrap::COMGETTER(InternalAndReservedAttribute8IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFsInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FsInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FsInfoWrap, IFsInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FsInfoWrap.cpp"


// ##### BEGINFILE "GuestFsInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFsInfo.
 *
 * 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_GUESTFSINFO

#include "GuestFsInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFsInfoWrap)

//
// IFsInfo properties
//

STDMETHODIMP GuestFsInfoWrap::COMGETTER(FreeSize)(LONG64 *aFreeSize)
{
    LogRelFlow(("{%p} %s: enter aFreeSize=%p\n", this, "GuestFsInfo::getFreeSize", aFreeSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFreeSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_FREESIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFreeSize(aFreeSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_FREESIZE_RETURN(this, hrc, 0 /*normal*/,*aFreeSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_FREESIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aFreeSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_FREESIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aFreeSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFreeSize=%RI64 hrc=%Rhrc\n", this, "GuestFsInfo::getFreeSize", !RT_VALID_PTR(aFreeSize) ? 0 : *aFreeSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(TotalSize)(LONG64 *aTotalSize)
{
    LogRelFlow(("{%p} %s: enter aTotalSize=%p\n", this, "GuestFsInfo::getTotalSize", aTotalSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTotalSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TOTALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTotalSize(aTotalSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TOTALSIZE_RETURN(this, hrc, 0 /*normal*/,*aTotalSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TOTALSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aTotalSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TOTALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aTotalSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTotalSize=%RI64 hrc=%Rhrc\n", this, "GuestFsInfo::getTotalSize", !RT_VALID_PTR(aTotalSize) ? 0 : *aTotalSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(BlockSize)(ULONG *aBlockSize)
{
    LogRelFlow(("{%p} %s: enter aBlockSize=%p\n", this, "GuestFsInfo::getBlockSize", aBlockSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBlockSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_BLOCKSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBlockSize(aBlockSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 0 /*normal*/,*aBlockSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aBlockSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_BLOCKSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBlockSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBlockSize=%RU32 hrc=%Rhrc\n", this, "GuestFsInfo::getBlockSize", !RT_VALID_PTR(aBlockSize) ? 0 : *aBlockSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(SectorSize)(ULONG *aSectorSize)
{
    LogRelFlow(("{%p} %s: enter aSectorSize=%p\n", this, "GuestFsInfo::getSectorSize", aSectorSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSectorSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SECTORSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSectorSize(aSectorSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SECTORSIZE_RETURN(this, hrc, 0 /*normal*/,*aSectorSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SECTORSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aSectorSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SECTORSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSectorSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSectorSize=%RU32 hrc=%Rhrc\n", this, "GuestFsInfo::getSectorSize", !RT_VALID_PTR(aSectorSize) ? 0 : *aSectorSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(SerialNumber)(ULONG *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "GuestFsInfo::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);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SERIALNUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSerialNumber(aSerialNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,*aSerialNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aSerialNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aSerialNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%RU32 hrc=%Rhrc\n", this, "GuestFsInfo::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(IsRemote)(BOOL *aIsRemote)
{
    LogRelFlow(("{%p} %s: enter aIsRemote=%p\n", this, "GuestFsInfo::getIsRemote", aIsRemote));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsRemote);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsRemote(aIsRemote);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREMOTE_RETURN(this, hrc, 0 /*normal*/,*aIsRemote != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREMOTE_RETURN(this, hrc, 1 /*hrc exception*/,*aIsRemote != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsRemote != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsRemote=%RTbool hrc=%Rhrc\n", this, "GuestFsInfo::getIsRemote", !RT_VALID_PTR(aIsRemote) ? 0 : *aIsRemote, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(IsCaseSensitive)(BOOL *aIsCaseSensitive)
{
    LogRelFlow(("{%p} %s: enter aIsCaseSensitive=%p\n", this, "GuestFsInfo::getIsCaseSensitive", aIsCaseSensitive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsCaseSensitive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCASESENSITIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCaseSensitive(aIsCaseSensitive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 0 /*normal*/,*aIsCaseSensitive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aIsCaseSensitive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCASESENSITIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCaseSensitive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsCaseSensitive=%RTbool hrc=%Rhrc\n", this, "GuestFsInfo::getIsCaseSensitive", !RT_VALID_PTR(aIsCaseSensitive) ? 0 : *aIsCaseSensitive, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(IsReadOnly)(BOOL *aIsReadOnly)
{
    LogRelFlow(("{%p} %s: enter aIsReadOnly=%p\n", this, "GuestFsInfo::getIsReadOnly", aIsReadOnly));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsReadOnly);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREADONLY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsReadOnly(aIsReadOnly);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREADONLY_RETURN(this, hrc, 0 /*normal*/,*aIsReadOnly != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREADONLY_RETURN(this, hrc, 1 /*hrc exception*/,*aIsReadOnly != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISREADONLY_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsReadOnly != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsReadOnly=%RTbool hrc=%Rhrc\n", this, "GuestFsInfo::getIsReadOnly", !RT_VALID_PTR(aIsReadOnly) ? 0 : *aIsReadOnly, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(IsCompressed)(BOOL *aIsCompressed)
{
    LogRelFlow(("{%p} %s: enter aIsCompressed=%p\n", this, "GuestFsInfo::getIsCompressed", aIsCompressed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsCompressed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCOMPRESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsCompressed(aIsCompressed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 0 /*normal*/,*aIsCompressed != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 1 /*hrc exception*/,*aIsCompressed != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_ISCOMPRESSED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsCompressed != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsCompressed=%RTbool hrc=%Rhrc\n", this, "GuestFsInfo::getIsCompressed", !RT_VALID_PTR(aIsCompressed) ? 0 : *aIsCompressed, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(SupportsFileCompression)(BOOL *aSupportsFileCompression)
{
    LogRelFlow(("{%p} %s: enter aSupportsFileCompression=%p\n", this, "GuestFsInfo::getSupportsFileCompression", aSupportsFileCompression));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportsFileCompression);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SUPPORTSFILECOMPRESSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportsFileCompression(aSupportsFileCompression);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 0 /*normal*/,*aSupportsFileCompression != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 1 /*hrc exception*/,*aSupportsFileCompression != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_SUPPORTSFILECOMPRESSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aSupportsFileCompression != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportsFileCompression=%RTbool hrc=%Rhrc\n", this, "GuestFsInfo::getSupportsFileCompression", !RT_VALID_PTR(aSupportsFileCompression) ? 0 : *aSupportsFileCompression, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(MaxComponent)(ULONG *aMaxComponent)
{
    LogRelFlow(("{%p} %s: enter aMaxComponent=%p\n", this, "GuestFsInfo::getMaxComponent", aMaxComponent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxComponent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MAXCOMPONENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxComponent(aMaxComponent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 0 /*normal*/,*aMaxComponent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxComponent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MAXCOMPONENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxComponent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxComponent=%RU32 hrc=%Rhrc\n", this, "GuestFsInfo::getMaxComponent", !RT_VALID_PTR(aMaxComponent) ? 0 : *aMaxComponent, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(Type)(BSTR *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestFsInfo::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);
        BSTROutConverter TmpType(aType);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(TmpType.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,TmpType.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%ls hrc=%Rhrc\n", this, "GuestFsInfo::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "GuestFsInfo::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_GUESTFSINFO_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_GUESTFSINFO_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_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_GUESTFSINFO_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "GuestFsInfo::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(MountPoint)(BSTR *aMountPoint)
{
    LogRelFlow(("{%p} %s: enter aMountPoint=%p\n", this, "GuestFsInfo::getMountPoint", aMountPoint));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMountPoint);
        BSTROutConverter TmpMountPoint(aMountPoint);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MOUNTPOINT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMountPoint(TmpMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 0 /*normal*/,TmpMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSINFO_GET_MOUNTPOINT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMountPoint=%ls hrc=%Rhrc\n", this, "GuestFsInfo::getMountPoint", !RT_VALID_PTR(aMountPoint) ? 0 : *aMountPoint, hrc));
    return hrc;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute1IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute2IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute3IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute4IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute5IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute6IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute7IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsInfoWrap::COMGETTER(InternalAndReservedAttribute8IFsInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestFsInfo properties
//

STDMETHODIMP GuestFsInfoWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestFsInfo::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, "GuestFsInfo::getMidlDoesNotLikeEmptyInterfaces", !RT_VALID_PTR(aMidlDoesNotLikeEmptyInterfaces) ? 0 : *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IFsInfo methods
//

//
// IGuestFsInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFsInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestFsInfoWrap, IGuestFsInfo, IFsInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFsInfoWrap.cpp"


// ##### BEGINFILE "GuestWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuest.
 *
 * 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_GUEST

#include "GuestWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestWrap)

//
// IGuest properties
//

STDMETHODIMP GuestWrap::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
{
    LogRelFlow(("{%p} %s: enter aOSTypeId=%p\n", this, "Guest::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_GUEST_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_GUEST_GET_OSTYPEID_RETURN(this, hrc, 0 /*normal*/,TmpOSTypeId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_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_GUEST_GET_OSTYPEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOSTypeId=%ls hrc=%Rhrc\n", this, "Guest::getOSTypeId", !RT_VALID_PTR(aOSTypeId) ? 0 : *aOSTypeId, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(AdditionsRunLevel)(AdditionsRunLevelType_T *aAdditionsRunLevel)
{
    LogRelFlow(("{%p} %s: enter aAdditionsRunLevel=%p\n", this, "Guest::getAdditionsRunLevel", aAdditionsRunLevel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdditionsRunLevel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSRUNLEVEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdditionsRunLevel(aAdditionsRunLevel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSRUNLEVEL_RETURN(this, hrc, 0 /*normal*/,*aAdditionsRunLevel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSRUNLEVEL_RETURN(this, hrc, 1 /*hrc exception*/,*aAdditionsRunLevel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSRUNLEVEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aAdditionsRunLevel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdditionsRunLevel=%RU32 hrc=%Rhrc\n", this, "Guest::getAdditionsRunLevel", !RT_VALID_PTR(aAdditionsRunLevel) ? 0 : *aAdditionsRunLevel, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(AdditionsVersion)(BSTR *aAdditionsVersion)
{
    LogRelFlow(("{%p} %s: enter aAdditionsVersion=%p\n", this, "Guest::getAdditionsVersion", aAdditionsVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdditionsVersion);
        BSTROutConverter TmpAdditionsVersion(aAdditionsVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdditionsVersion(TmpAdditionsVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSVERSION_RETURN(this, hrc, 0 /*normal*/,TmpAdditionsVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSVERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdditionsVersion=%ls hrc=%Rhrc\n", this, "Guest::getAdditionsVersion", !RT_VALID_PTR(aAdditionsVersion) ? 0 : *aAdditionsVersion, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(AdditionsRevision)(ULONG *aAdditionsRevision)
{
    LogRelFlow(("{%p} %s: enter aAdditionsRevision=%p\n", this, "Guest::getAdditionsRevision", aAdditionsRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdditionsRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSREVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdditionsRevision(aAdditionsRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSREVISION_RETURN(this, hrc, 0 /*normal*/,*aAdditionsRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSREVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aAdditionsRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_ADDITIONSREVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aAdditionsRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdditionsRevision=%RU32 hrc=%Rhrc\n", this, "Guest::getAdditionsRevision", !RT_VALID_PTR(aAdditionsRevision) ? 0 : *aAdditionsRevision, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(DnDSource)(IGuestDnDSource **aDnDSource)
{
    LogRelFlow(("{%p} %s: enter aDnDSource=%p\n", this, "Guest::getDnDSource", aDnDSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDnDSource);
        ComTypeOutConverter<IGuestDnDSource> TmpDnDSource(aDnDSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDnDSource(TmpDnDSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpDnDSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDnDSource=%p hrc=%Rhrc\n", this, "Guest::getDnDSource", !RT_VALID_PTR(aDnDSource) ? 0 : *aDnDSource, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(DnDTarget)(IGuestDnDTarget **aDnDTarget)
{
    LogRelFlow(("{%p} %s: enter aDnDTarget=%p\n", this, "Guest::getDnDTarget", aDnDTarget));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDnDTarget);
        ComTypeOutConverter<IGuestDnDTarget> TmpDnDTarget(aDnDTarget);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDTARGET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDnDTarget(TmpDnDTarget.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDTARGET_RETURN(this, hrc, 0 /*normal*/,(void *)TmpDnDTarget.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDTARGET_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_DNDTARGET_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDnDTarget=%p hrc=%Rhrc\n", this, "Guest::getDnDTarget", !RT_VALID_PTR(aDnDTarget) ? 0 : *aDnDTarget, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Guest::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_GUEST_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_GUEST_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_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_GUEST_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Guest::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(Facilities)(ComSafeArrayOut(IAdditionsFacility *, aFacilities))
{
    LogRelFlow(("{%p} %s: enter aFacilities=%p\n", this, "Guest::getFacilities", aFacilities));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFacilities);
        ArrayComTypeOutConverter<IAdditionsFacility> TmpFacilities(ComSafeArrayOutArg(aFacilities));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_FACILITIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFacilities(TmpFacilities.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_FACILITIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFacilities.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_FACILITIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_FACILITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFacilities=%zu hrc=%Rhrc\n", this, "Guest::getFacilities", !RT_VALID_PTR(aFacilities) ? 0 : ComSafeArraySize(*aFacilities), hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(Sessions)(ComSafeArrayOut(IGuestSession *, aSessions))
{
    LogRelFlow(("{%p} %s: enter aSessions=%p\n", this, "Guest::getSessions", aSessions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSessions);
        ArrayComTypeOutConverter<IGuestSession> TmpSessions(ComSafeArrayOutArg(aSessions));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_SESSIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSessions(TmpSessions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_SESSIONS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSessions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_SESSIONS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_SESSIONS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSessions=%zu hrc=%Rhrc\n", this, "Guest::getSessions", !RT_VALID_PTR(aSessions) ? 0 : ComSafeArraySize(*aSessions), hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(MemoryBalloonSize)(ULONG *aMemoryBalloonSize)
{
    LogRelFlow(("{%p} %s: enter aMemoryBalloonSize=%p\n", this, "Guest::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_GUEST_GET_MEMORYBALLOONSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMemoryBalloonSize(aMemoryBalloonSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_MEMORYBALLOONSIZE_RETURN(this, hrc, 0 /*normal*/,*aMemoryBalloonSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_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_GUEST_GET_MEMORYBALLOONSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMemoryBalloonSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMemoryBalloonSize=%RU32 hrc=%Rhrc\n", this, "Guest::getMemoryBalloonSize", !RT_VALID_PTR(aMemoryBalloonSize) ? 0 : *aMemoryBalloonSize, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMSETTER(MemoryBalloonSize)(ULONG aMemoryBalloonSize)
{
    LogRelFlow(("{%p} %s: enter aMemoryBalloonSize=%RU32\n", this, "Guest::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_GUEST_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_GUEST_SET_MEMORYBALLOONSIZE_RETURN(this, hrc, 0 /*normal*/,aMemoryBalloonSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_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_GUEST_SET_MEMORYBALLOONSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,aMemoryBalloonSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Guest::setMemoryBalloonSize", hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(StatisticsUpdateInterval)(ULONG *aStatisticsUpdateInterval)
{
    LogRelFlow(("{%p} %s: enter aStatisticsUpdateInterval=%p\n", this, "Guest::getStatisticsUpdateInterval", aStatisticsUpdateInterval));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatisticsUpdateInterval);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_STATISTICSUPDATEINTERVAL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatisticsUpdateInterval(aStatisticsUpdateInterval);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 0 /*normal*/,*aStatisticsUpdateInterval);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 1 /*hrc exception*/,*aStatisticsUpdateInterval);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatisticsUpdateInterval);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatisticsUpdateInterval=%RU32 hrc=%Rhrc\n", this, "Guest::getStatisticsUpdateInterval", !RT_VALID_PTR(aStatisticsUpdateInterval) ? 0 : *aStatisticsUpdateInterval, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMSETTER(StatisticsUpdateInterval)(ULONG aStatisticsUpdateInterval)
{
    LogRelFlow(("{%p} %s: enter aStatisticsUpdateInterval=%RU32\n", this, "Guest::setStatisticsUpdateInterval", aStatisticsUpdateInterval));

    // Clear 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_GUEST_SET_STATISTICSUPDATEINTERVAL_ENTER(this, aStatisticsUpdateInterval);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setStatisticsUpdateInterval(aStatisticsUpdateInterval);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 0 /*normal*/,aStatisticsUpdateInterval);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 1 /*hrc exception*/,aStatisticsUpdateInterval);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SET_STATISTICSUPDATEINTERVAL_RETURN(this, hrc, 9 /*unhandled exception*/,aStatisticsUpdateInterval);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Guest::setStatisticsUpdateInterval", hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute1IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute2IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute3IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute4IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute5IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute6IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute7IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute8IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute9IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute10IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute11IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute12IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute13IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute14IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute15IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::COMGETTER(InternalAndReservedAttribute16IGuest)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuest methods
//

STDMETHODIMP GuestWrap::InternalGetStatistics(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)
{
    LogRelFlow(("{%p} %s: enter aCpuUser=%p aCpuKernel=%p aCpuIdle=%p aMemTotal=%p aMemFree=%p aMemBalloon=%p aMemShared=%p aMemCache=%p aPagedTotal=%p aMemAllocTotal=%p aMemFreeTotal=%p aMemBalloonTotal=%p aMemSharedTotal=%p\n", this, "Guest::internalGetStatistics", aCpuUser, aCpuKernel, aCpuIdle, aMemTotal, aMemFree, aMemBalloon, aMemShared, aMemCache, aPagedTotal, aMemAllocTotal, aMemFreeTotal, aMemBalloonTotal, aMemSharedTotal));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCpuUser);
        CheckComArgOutPointerValidThrow(aCpuKernel);
        CheckComArgOutPointerValidThrow(aCpuIdle);
        CheckComArgOutPointerValidThrow(aMemTotal);
        CheckComArgOutPointerValidThrow(aMemFree);
        CheckComArgOutPointerValidThrow(aMemBalloon);
        CheckComArgOutPointerValidThrow(aMemShared);
        CheckComArgOutPointerValidThrow(aMemCache);
        CheckComArgOutPointerValidThrow(aPagedTotal);
        CheckComArgOutPointerValidThrow(aMemAllocTotal);
        CheckComArgOutPointerValidThrow(aMemFreeTotal);
        CheckComArgOutPointerValidThrow(aMemBalloonTotal);
        CheckComArgOutPointerValidThrow(aMemSharedTotal);


        
        
        
        
        
        
        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_INTERNALGETSTATISTICS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = internalGetStatistics(aCpuUser,
                                        aCpuKernel,
                                        aCpuIdle,
                                        aMemTotal,
                                        aMemFree,
                                        aMemBalloon,
                                        aMemShared,
                                        aMemCache,
                                        aPagedTotal,
                                        aMemAllocTotal,
                                        aMemFreeTotal,
                                        aMemBalloonTotal,
                                        aMemSharedTotal);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_INTERNALGETSTATISTICS_RETURN(this, hrc, 0 /*normal*/, *aCpuUser, *aCpuKernel, *aCpuIdle, *aMemTotal, *aMemFree, *aMemBalloon, *aMemShared, *aMemCache, *aPagedTotal, *aMemAllocTotal, *aMemFreeTotal, *aMemBalloonTotal, *aMemSharedTotal);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_INTERNALGETSTATISTICS_RETURN(this, hrc, 1 /*hrc exception*/, *aCpuUser, *aCpuKernel, *aCpuIdle, *aMemTotal, *aMemFree, *aMemBalloon, *aMemShared, *aMemCache, *aPagedTotal, *aMemAllocTotal, *aMemFreeTotal, *aMemBalloonTotal, *aMemSharedTotal);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_INTERNALGETSTATISTICS_RETURN(this, hrc, 9 /*unhandled exception*/, *aCpuUser, *aCpuKernel, *aCpuIdle, *aMemTotal, *aMemFree, *aMemBalloon, *aMemShared, *aMemCache, *aPagedTotal, *aMemAllocTotal, *aMemFreeTotal, *aMemBalloonTotal, *aMemSharedTotal);
#endif
    }

    LogRelFlow(("{%p} %s: leave *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 hrc=%Rhrc\n", this, "Guest::internalGetStatistics", !RT_VALID_PTR(aCpuUser) ? 0 : *aCpuUser, !RT_VALID_PTR(aCpuKernel) ? 0 : *aCpuKernel, !RT_VALID_PTR(aCpuIdle) ? 0 : *aCpuIdle, !RT_VALID_PTR(aMemTotal) ? 0 : *aMemTotal, !RT_VALID_PTR(aMemFree) ? 0 : *aMemFree, !RT_VALID_PTR(aMemBalloon) ? 0 : *aMemBalloon, !RT_VALID_PTR(aMemShared) ? 0 : *aMemShared, !RT_VALID_PTR(aMemCache) ? 0 : *aMemCache, !RT_VALID_PTR(aPagedTotal) ? 0 : *aPagedTotal, !RT_VALID_PTR(aMemAllocTotal) ? 0 : *aMemAllocTotal, !RT_VALID_PTR(aMemFreeTotal) ? 0 : *aMemFreeTotal, !RT_VALID_PTR(aMemBalloonTotal) ? 0 : *aMemBalloonTotal, !RT_VALID_PTR(aMemSharedTotal) ? 0 : *aMemSharedTotal, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::GetFacilityStatus(AdditionsFacilityType_T aFacility,
                                          LONG64 *aTimestamp,
                                          AdditionsFacilityStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aFacility=%RU32 aTimestamp=%p aStatus=%p\n", this, "Guest::getFacilityStatus", aFacility, aTimestamp, 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(aTimestamp);
        CheckComArgOutPointerValidThrow(aStatus);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETFACILITYSTATUS_ENTER(this, aFacility);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFacilityStatus(aFacility,
                                    aTimestamp,
                                    aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETFACILITYSTATUS_RETURN(this, hrc, 0 /*normal*/, aFacility, *aTimestamp, *aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETFACILITYSTATUS_RETURN(this, hrc, 1 /*hrc exception*/, aFacility, *aTimestamp, *aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETFACILITYSTATUS_RETURN(this, hrc, 9 /*unhandled exception*/, aFacility, *aTimestamp, *aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimestamp=%RI64 aStatus=%RU32 hrc=%Rhrc\n", this, "Guest::getFacilityStatus", !RT_VALID_PTR(aTimestamp) ? 0 : *aTimestamp, !RT_VALID_PTR(aStatus) ? 0 : *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::GetAdditionsStatus(AdditionsRunLevelType_T aLevel,
                                           BOOL *aActive)
{
    LogRelFlow(("{%p} %s: enter aLevel=%RU32 aActive=%p\n", this, "Guest::getAdditionsStatus", aLevel, 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_GUEST_GETADDITIONSSTATUS_ENTER(this, aLevel);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdditionsStatus(aLevel,
                                     aActive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETADDITIONSSTATUS_RETURN(this, hrc, 0 /*normal*/, aLevel, *aActive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETADDITIONSSTATUS_RETURN(this, hrc, 1 /*hrc exception*/, aLevel, *aActive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_GETADDITIONSSTATUS_RETURN(this, hrc, 9 /*unhandled exception*/, aLevel, *aActive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aActive=%RTbool hrc=%Rhrc\n", this, "Guest::getAdditionsStatus", !RT_VALID_PTR(aActive) ? 0 : *aActive, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::SetCredentials(IN_BSTR aUserName,
                                       IN_BSTR aPassword,
                                       IN_BSTR aDomain,
                                       BOOL aAllowInteractiveLogon)
{
    LogRelFlow(("{%p} %s: enter aUserName=%ls aPassword=%ls aDomain=%ls aAllowInteractiveLogon=%RTbool\n", this, "Guest::setCredentials", aUserName, aPassword, aDomain, aAllowInteractiveLogon));

    // Clear 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 TmpUserName(aUserName);
        BSTRInConverter TmpPassword(aPassword);
        BSTRInConverter TmpDomain(aDomain);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SETCREDENTIALS_ENTER(this, TmpUserName.str().c_str(), TmpPassword.str().c_str(), TmpDomain.str().c_str(), aAllowInteractiveLogon != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCredentials(TmpUserName.str(),
                                 TmpPassword.str(),
                                 TmpDomain.str(),
                                 aAllowInteractiveLogon != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SETCREDENTIALS_RETURN(this, hrc, 0 /*normal*/, TmpUserName.str().c_str(), TmpPassword.str().c_str(), TmpDomain.str().c_str(), aAllowInteractiveLogon != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SETCREDENTIALS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aAllowInteractiveLogon != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SETCREDENTIALS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aAllowInteractiveLogon != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Guest::setCredentials", hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::CreateSession(IN_BSTR aUser,
                                      IN_BSTR aPassword,
                                      IN_BSTR aDomain,
                                      IN_BSTR aSessionName,
                                      IGuestSession **aGuestSession)
{
    LogRelFlow(("{%p} %s: enter aUser=%ls aPassword=%ls aDomain=%ls aSessionName=%ls aGuestSession=%p\n", this, "Guest::createSession", aUser, aPassword, aDomain, aSessionName, aGuestSession));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestSession);


        BSTRInConverter TmpUser(aUser);
        BSTRInConverter TmpPassword(aPassword);
        BSTRInConverter TmpDomain(aDomain);
        BSTRInConverter TmpSessionName(aSessionName);
        ComTypeOutConverter<IGuestSession> TmpGuestSession(aGuestSession);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_CREATESESSION_ENTER(this, TmpUser.str().c_str(), TmpPassword.str().c_str(), TmpDomain.str().c_str(), TmpSessionName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createSession(TmpUser.str(),
                                TmpPassword.str(),
                                TmpDomain.str(),
                                TmpSessionName.str(),
                                TmpGuestSession.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_CREATESESSION_RETURN(this, hrc, 0 /*normal*/, TmpUser.str().c_str(), TmpPassword.str().c_str(), TmpDomain.str().c_str(), TmpSessionName.str().c_str(), (void *)TmpGuestSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_CREATESESSION_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_GUEST_CREATESESSION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestSession=%p hrc=%Rhrc\n", this, "Guest::createSession", !RT_VALID_PTR(aGuestSession) ? 0 : *aGuestSession, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::FindSession(IN_BSTR aSessionName,
                                    ComSafeArrayOut(IGuestSession *, aSessions))
{
    LogRelFlow(("{%p} %s: enter aSessionName=%ls aSessions=%p\n", this, "Guest::findSession", aSessionName, aSessions));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSessions);


        BSTRInConverter TmpSessionName(aSessionName);
        ArrayComTypeOutConverter<IGuestSession> TmpSessions(ComSafeArrayOutArg(aSessions));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_FINDSESSION_ENTER(this, TmpSessionName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = findSession(TmpSessionName.str(),
                              TmpSessions.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_FINDSESSION_RETURN(this, hrc, 0 /*normal*/, TmpSessionName.str().c_str(), (uint32_t)TmpSessions.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_FINDSESSION_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_GUEST_FINDSESSION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSessions=%zu hrc=%Rhrc\n", this, "Guest::findSession", !RT_VALID_PTR(aSessions) ? 0 : ComSafeArraySize(*aSessions), hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::Shutdown(ComSafeArrayIn(GuestShutdownFlag_T, aFlags))
{
    LogRelFlow(("{%p} %s: enter aFlags=%zu\n", this, "Guest::shutdown", 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
    {


        ArrayInConverter<GuestShutdownFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SHUTDOWN_ENTER(this, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = shutdown(TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SHUTDOWN_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SHUTDOWN_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_SHUTDOWN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Guest::shutdown", hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::UpdateGuestAdditions(IN_BSTR aSource,
                                             ComSafeArrayIn(IN_BSTR, aArguments),
                                             ComSafeArrayIn(AdditionsUpdateFlag_T, aFlags),
                                             IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSource=%ls aArguments=%zu aFlags=%zu aProgress=%p\n", this, "Guest::updateGuestAdditions", aSource, aArguments, 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);
        ArrayBSTRInConverter TmpArguments(ComSafeArrayInArg(aArguments));
        ArrayInConverter<AdditionsUpdateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_UPDATEGUESTADDITIONS_ENTER(this, TmpSource.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = updateGuestAdditions(TmpSource.str(),
                                       TmpArguments.array(),
                                       TmpFlags.array(),
                                       TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_UPDATEGUESTADDITIONS_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUEST_UPDATEGUESTADDITIONS_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_GUEST_UPDATEGUESTADDITIONS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Guest::updateGuestAdditions", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod1IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod2IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod3IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod4IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod5IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod6IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod7IGuest()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestWrap::InternalAndReservedMethod8IGuest()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestWrap, IGuest)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestWrap.cpp"


// ##### BEGINFILE "MediumWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMedium.
 *
 * 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_MEDIUM

#include "MediumWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumWrap)

//
// IMedium properties
//

STDMETHODIMP MediumWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Medium::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_MEDIUM_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_MEDIUM_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_MEDIUM_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_MEDIUM_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Medium::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Medium::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_MEDIUM_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(autoCaller, TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Medium::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMSETTER(Description)(IN_BSTR aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%ls\n", this, "Medium::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_MEDIUM_SET_DESCRIPTION_ENTER(this, TmpDescription.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDescription(autoCaller, TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_SET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setDescription", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(State)(MediumState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Medium::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_MEDIUM_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "Medium::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Variant)(ComSafeArrayOut(MediumVariant_T, aVariant))
{
    LogRelFlow(("{%p} %s: enter aVariant=%p\n", this, "Medium::getVariant", aVariant));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVariant);
        ArrayOutConverter<MediumVariant_T> TmpVariant(ComSafeArrayOutArg(aVariant));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_VARIANT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVariant(TmpVariant.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_VARIANT_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpVariant.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_VARIANT_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_VARIANT_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVariant=%zu hrc=%Rhrc\n", this, "Medium::getVariant", !RT_VALID_PTR(aVariant) ? 0 : ComSafeArraySize(*aVariant), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Location)(BSTR *aLocation)
{
    LogRelFlow(("{%p} %s: enter aLocation=%p\n", this, "Medium::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_MEDIUM_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_MEDIUM_GET_LOCATION_RETURN(this, hrc, 0 /*normal*/,TmpLocation.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_LOCATION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLocation=%ls hrc=%Rhrc\n", this, "Medium::getLocation", !RT_VALID_PTR(aLocation) ? 0 : *aLocation, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMSETTER(Location)(IN_BSTR aLocation)
{
    LogRelFlow(("{%p} %s: enter aLocation=%ls\n", this, "Medium::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_MEDIUM_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_MEDIUM_SET_LOCATION_RETURN(this, hrc, 0 /*normal*/,TmpLocation.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_SET_LOCATION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setLocation", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Medium::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_MEDIUM_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_MEDIUM_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Medium::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(DeviceType)(DeviceType_T *aDeviceType)
{
    LogRelFlow(("{%p} %s: enter aDeviceType=%p\n", this, "Medium::getDeviceType", aDeviceType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_DEVICETYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceType(aDeviceType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_DEVICETYPE_RETURN(this, hrc, 0 /*normal*/,*aDeviceType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_DEVICETYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aDeviceType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_DEVICETYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aDeviceType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceType=%RU32 hrc=%Rhrc\n", this, "Medium::getDeviceType", !RT_VALID_PTR(aDeviceType) ? 0 : *aDeviceType, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(HostDrive)(BOOL *aHostDrive)
{
    LogRelFlow(("{%p} %s: enter aHostDrive=%p\n", this, "Medium::getHostDrive", aHostDrive));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostDrive);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_HOSTDRIVE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostDrive(aHostDrive);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_HOSTDRIVE_RETURN(this, hrc, 0 /*normal*/,*aHostDrive != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_HOSTDRIVE_RETURN(this, hrc, 1 /*hrc exception*/,*aHostDrive != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_HOSTDRIVE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHostDrive != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostDrive=%RTbool hrc=%Rhrc\n", this, "Medium::getHostDrive", !RT_VALID_PTR(aHostDrive) ? 0 : *aHostDrive, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Size)(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s: enter aSize=%p\n", this, "Medium::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_MEDIUM_GET_SIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_SIZE_RETURN(this, hrc, 0 /*normal*/,*aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_SIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSize=%RI64 hrc=%Rhrc\n", this, "Medium::getSize", !RT_VALID_PTR(aSize) ? 0 : *aSize, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Format)(BSTR *aFormat)
{
    LogRelFlow(("{%p} %s: enter aFormat=%p\n", this, "Medium::getFormat", aFormat));

    // Clear error 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);
        BSTROutConverter TmpFormat(aFormat);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_FORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFormat(TmpFormat.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_FORMAT_RETURN(this, hrc, 0 /*normal*/,TmpFormat.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_FORMAT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_FORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormat=%ls hrc=%Rhrc\n", this, "Medium::getFormat", !RT_VALID_PTR(aFormat) ? 0 : *aFormat, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(MediumFormat)(IMediumFormat **aMediumFormat)
{
    LogRelFlow(("{%p} %s: enter aMediumFormat=%p\n", this, "Medium::getMediumFormat", aMediumFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMediumFormat);
        ComTypeOutConverter<IMediumFormat> TmpMediumFormat(aMediumFormat);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MEDIUMFORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMediumFormat(TmpMediumFormat.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MEDIUMFORMAT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMediumFormat.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MEDIUMFORMAT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MEDIUMFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMediumFormat=%p hrc=%Rhrc\n", this, "Medium::getMediumFormat", !RT_VALID_PTR(aMediumFormat) ? 0 : *aMediumFormat, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Type)(MediumType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "Medium::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_MEDIUM_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(autoCaller, aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "Medium::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMSETTER(Type)(MediumType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "Medium::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_MEDIUM_SET_TYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setType(autoCaller, aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SET_TYPE_RETURN(this, hrc, 0 /*normal*/,aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_SET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setType", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(AllowedTypes)(ComSafeArrayOut(MediumType_T, aAllowedTypes))
{
    LogRelFlow(("{%p} %s: enter aAllowedTypes=%p\n", this, "Medium::getAllowedTypes", aAllowedTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllowedTypes);
        ArrayOutConverter<MediumType_T> TmpAllowedTypes(ComSafeArrayOutArg(aAllowedTypes));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_ALLOWEDTYPES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllowedTypes(TmpAllowedTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_ALLOWEDTYPES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpAllowedTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_ALLOWEDTYPES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_ALLOWEDTYPES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllowedTypes=%zu hrc=%Rhrc\n", this, "Medium::getAllowedTypes", !RT_VALID_PTR(aAllowedTypes) ? 0 : ComSafeArraySize(*aAllowedTypes), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Parent)(IMedium **aParent)
{
    LogRelFlow(("{%p} %s: enter aParent=%p\n", this, "Medium::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<IMedium> TmpParent(aParent);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_PARENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParent(autoCaller, TmpParent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_PARENT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpParent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_GET_PARENT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParent=%p hrc=%Rhrc\n", this, "Medium::getParent", !RT_VALID_PTR(aParent) ? 0 : *aParent, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Children)(ComSafeArrayOut(IMedium *, aChildren))
{
    LogRelFlow(("{%p} %s: enter aChildren=%p\n", this, "Medium::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<IMedium> TmpChildren(ComSafeArrayOutArg(aChildren));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_CHILDREN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChildren(autoCaller, TmpChildren.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_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_MEDIUM_GET_CHILDREN_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChildren=%zu hrc=%Rhrc\n", this, "Medium::getChildren", !RT_VALID_PTR(aChildren) ? 0 : ComSafeArraySize(*aChildren), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(Base)(IMedium **aBase)
{
    LogRelFlow(("{%p} %s: enter aBase=%p\n", this, "Medium::getBase", aBase));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBase);
        ComTypeOutConverter<IMedium> TmpBase(aBase);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_BASE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBase(autoCaller, TmpBase.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_BASE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBase.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_BASE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_BASE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBase=%p hrc=%Rhrc\n", this, "Medium::getBase", !RT_VALID_PTR(aBase) ? 0 : *aBase, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(ReadOnly)(BOOL *aReadOnly)
{
    LogRelFlow(("{%p} %s: enter aReadOnly=%p\n", this, "Medium::getReadOnly", aReadOnly));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReadOnly);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_READONLY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReadOnly(autoCaller, aReadOnly);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_READONLY_RETURN(this, hrc, 0 /*normal*/,*aReadOnly != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_READONLY_RETURN(this, hrc, 1 /*hrc exception*/,*aReadOnly != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_READONLY_RETURN(this, hrc, 9 /*unhandled exception*/,*aReadOnly != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReadOnly=%RTbool hrc=%Rhrc\n", this, "Medium::getReadOnly", !RT_VALID_PTR(aReadOnly) ? 0 : *aReadOnly, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(LogicalSize)(LONG64 *aLogicalSize)
{
    LogRelFlow(("{%p} %s: enter aLogicalSize=%p\n", this, "Medium::getLogicalSize", aLogicalSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogicalSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LOGICALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogicalSize(aLogicalSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LOGICALSIZE_RETURN(this, hrc, 0 /*normal*/,*aLogicalSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LOGICALSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aLogicalSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LOGICALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogicalSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogicalSize=%RI64 hrc=%Rhrc\n", this, "Medium::getLogicalSize", !RT_VALID_PTR(aLogicalSize) ? 0 : *aLogicalSize, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(AutoReset)(BOOL *aAutoReset)
{
    LogRelFlow(("{%p} %s: enter aAutoReset=%p\n", this, "Medium::getAutoReset", aAutoReset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutoReset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_AUTORESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutoReset(aAutoReset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_AUTORESET_RETURN(this, hrc, 0 /*normal*/,*aAutoReset != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_AUTORESET_RETURN(this, hrc, 1 /*hrc exception*/,*aAutoReset != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_AUTORESET_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutoReset != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutoReset=%RTbool hrc=%Rhrc\n", this, "Medium::getAutoReset", !RT_VALID_PTR(aAutoReset) ? 0 : *aAutoReset, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMSETTER(AutoReset)(BOOL aAutoReset)
{
    LogRelFlow(("{%p} %s: enter aAutoReset=%RTbool\n", this, "Medium::setAutoReset", aAutoReset));

    // Clear 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_MEDIUM_SET_AUTORESET_ENTER(this, aAutoReset != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutoReset(aAutoReset != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SET_AUTORESET_RETURN(this, hrc, 0 /*normal*/,aAutoReset != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SET_AUTORESET_RETURN(this, hrc, 1 /*hrc exception*/,aAutoReset != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SET_AUTORESET_RETURN(this, hrc, 9 /*unhandled exception*/,aAutoReset != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setAutoReset", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(LastAccessError)(BSTR *aLastAccessError)
{
    LogRelFlow(("{%p} %s: enter aLastAccessError=%p\n", this, "Medium::getLastAccessError", aLastAccessError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastAccessError);
        BSTROutConverter TmpLastAccessError(aLastAccessError);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LASTACCESSERROR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastAccessError(TmpLastAccessError.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LASTACCESSERROR_RETURN(this, hrc, 0 /*normal*/,TmpLastAccessError.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LASTACCESSERROR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_LASTACCESSERROR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastAccessError=%ls hrc=%Rhrc\n", this, "Medium::getLastAccessError", !RT_VALID_PTR(aLastAccessError) ? 0 : *aLastAccessError, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(MachineIds)(ComSafeArrayOut(BSTR, aMachineIds))
{
    LogRelFlow(("{%p} %s: enter aMachineIds=%p\n", this, "Medium::getMachineIds", aMachineIds));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachineIds);
        ArrayUuidOutConverter TmpMachineIds(ComSafeArrayOutArg(aMachineIds));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MACHINEIDS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachineIds(TmpMachineIds.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MACHINEIDS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMachineIds.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MACHINEIDS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GET_MACHINEIDS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachineIds=%zu hrc=%Rhrc\n", this, "Medium::getMachineIds", !RT_VALID_PTR(aMachineIds) ? 0 : ComSafeArraySize(*aMachineIds), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute1IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute2IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute3IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute4IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute5IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute6IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute7IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute8IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute9IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute10IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute11IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::COMGETTER(InternalAndReservedAttribute12IMedium)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMedium methods
//

STDMETHODIMP MediumWrap::SetIds(BOOL aSetImageId,
                                IN_BSTR aImageId,
                                BOOL aSetParentId,
                                IN_BSTR aParentId)
{
    LogRelFlow(("{%p} %s: enter aSetImageId=%RTbool aImageId=%ls aSetParentId=%RTbool aParentId=%ls\n", this, "Medium::setIds", aSetImageId, aImageId, aSetParentId, aParentId));

    // Clear 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 TmpImageId(aImageId);
        
        UuidInConverter TmpParentId(aParentId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SETIDS_ENTER(this, aSetImageId != FALSE, TmpImageId.uuid().toStringCurly().c_str(), aSetParentId != FALSE, TmpParentId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIds(autoCaller,
                     aSetImageId != FALSE,
                         TmpImageId.uuid(),
                         aSetParentId != FALSE,
                         TmpParentId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SETIDS_RETURN(this, hrc, 0 /*normal*/, aSetImageId != FALSE, TmpImageId.uuid().toStringCurly().c_str(), aSetParentId != FALSE, TmpParentId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SETIDS_RETURN(this, hrc, 1 /*hrc exception*/, aSetImageId != FALSE, 0, aSetParentId != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_SETIDS_RETURN(this, hrc, 9 /*unhandled exception*/, aSetImageId != FALSE, 0, aSetParentId != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setIds", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::RefreshState(MediumState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Medium::refreshState", 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_MEDIUM_REFRESHSTATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = refreshState(autoCaller,
                           aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_REFRESHSTATE_RETURN(this, hrc, 0 /*normal*/, *aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_REFRESHSTATE_RETURN(this, hrc, 1 /*hrc exception*/, *aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_REFRESHSTATE_RETURN(this, hrc, 9 /*unhandled exception*/, *aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave aState=%RU32 hrc=%Rhrc\n", this, "Medium::refreshState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::GetSnapshotIds(IN_BSTR aMachineId,
                                        ComSafeArrayOut(BSTR, aSnapshotIds))
{
    LogRelFlow(("{%p} %s: enter aMachineId=%ls aSnapshotIds=%p\n", this, "Medium::getSnapshotIds", aMachineId, aSnapshotIds));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSnapshotIds);


        UuidInConverter TmpMachineId(aMachineId);
        ArrayUuidOutConverter TmpSnapshotIds(ComSafeArrayOutArg(aSnapshotIds));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GETSNAPSHOTIDS_ENTER(this, TmpMachineId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSnapshotIds(TmpMachineId.uuid(),
                                 TmpSnapshotIds.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GETSNAPSHOTIDS_RETURN(this, hrc, 0 /*normal*/, TmpMachineId.uuid().toStringCurly().c_str(), (uint32_t)TmpSnapshotIds.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_GETSNAPSHOTIDS_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_MEDIUM_GETSNAPSHOTIDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSnapshotIds=%zu hrc=%Rhrc\n", this, "Medium::getSnapshotIds", !RT_VALID_PTR(aSnapshotIds) ? 0 : ComSafeArraySize(*aSnapshotIds), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::LockRead(IToken **aToken)
{
    LogRelFlow(("{%p} %s: enter aToken=%p\n", this, "Medium::lockRead", 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
    {
        CheckComArgOutPointerValidThrow(aToken);


        ComTypeOutConverter<IToken> TmpToken(aToken);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKREAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = lockRead(TmpToken.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKREAD_RETURN(this, hrc, 0 /*normal*/, (void *)TmpToken.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKREAD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKREAD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aToken=%p hrc=%Rhrc\n", this, "Medium::lockRead", !RT_VALID_PTR(aToken) ? 0 : *aToken, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::LockWrite(IToken **aToken)
{
    LogRelFlow(("{%p} %s: enter aToken=%p\n", this, "Medium::lockWrite", 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
    {
        CheckComArgOutPointerValidThrow(aToken);


        ComTypeOutConverter<IToken> TmpToken(aToken);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKWRITE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = lockWrite(TmpToken.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKWRITE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpToken.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKWRITE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_LOCKWRITE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aToken=%p hrc=%Rhrc\n", this, "Medium::lockWrite", !RT_VALID_PTR(aToken) ? 0 : *aToken, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::Close()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Medium::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_MEDIUM_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = close(autoCaller);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::close", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::GetProperty(IN_BSTR aName,
                                     BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%p\n", this, "Medium::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_MEDIUM_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_MEDIUM_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_MEDIUM_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_MEDIUM_GETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "Medium::getProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::SetProperty(IN_BSTR aName,
                                     IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aValue=%ls\n", this, "Medium::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_MEDIUM_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_MEDIUM_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_MEDIUM_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_MEDIUM_SETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setProperty", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::GetProperties(IN_BSTR aNames,
                                       ComSafeArrayOut(BSTR, aReturnNames),
                                       ComSafeArrayOut(BSTR, aReturnValues))
{
    LogRelFlow(("{%p} %s: enter aNames=%ls aReturnNames=%p aReturnValues=%p\n", this, "Medium::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_MEDIUM_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_MEDIUM_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_MEDIUM_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_MEDIUM_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, "Medium::getProperties", !RT_VALID_PTR(aReturnNames) ? 0 : ComSafeArraySize(*aReturnNames), !RT_VALID_PTR(aReturnValues) ? 0 : ComSafeArraySize(*aReturnValues), hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::SetProperties(ComSafeArrayIn(IN_BSTR, aNames),
                                       ComSafeArrayIn(IN_BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aNames=%zu aValues=%zu\n", this, "Medium::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_MEDIUM_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_MEDIUM_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_MEDIUM_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_MEDIUM_SETPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::setProperties", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::CreateBaseStorage(LONG64 aLogicalSize,
                                           ComSafeArrayIn(MediumVariant_T, aVariant),
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aLogicalSize=%RI64 aVariant=%zu aProgress=%p\n", this, "Medium::createBaseStorage", aLogicalSize, aVariant, 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);


        
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEBASESTORAGE_ENTER(this, aLogicalSize, (uint32_t)TmpVariant.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createBaseStorage(aLogicalSize,
                                    TmpVariant.array(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEBASESTORAGE_RETURN(this, hrc, 0 /*normal*/, aLogicalSize, (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEBASESTORAGE_RETURN(this, hrc, 1 /*hrc exception*/, aLogicalSize, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEBASESTORAGE_RETURN(this, hrc, 9 /*unhandled exception*/, aLogicalSize, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::createBaseStorage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::DeleteStorage(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Medium::deleteStorage", 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_MEDIUM_DELETESTORAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteStorage(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_DELETESTORAGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_DELETESTORAGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_DELETESTORAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::deleteStorage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::CreateDiffStorage(IMedium *aTarget,
                                           ComSafeArrayIn(MediumVariant_T, aVariant),
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aVariant=%zu aProgress=%p\n", this, "Medium::createDiffStorage", aTarget, aVariant, 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<IMedium> TmpTarget(aTarget);
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEDIFFSTORAGE_ENTER(this, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createDiffStorage(autoCaller,
                                TmpTarget.ptr(),
                                    TmpVariant.array(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEDIFFSTORAGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CREATEDIFFSTORAGE_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_MEDIUM_CREATEDIFFSTORAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::createDiffStorage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::MergeTo(IMedium *aTarget,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aProgress=%p\n", this, "Medium::mergeTo", aTarget, 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<IMedium> TmpTarget(aTarget);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MERGETO_ENTER(this, (void *)TmpTarget.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = mergeTo(TmpTarget.ptr(),
                          TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MERGETO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MERGETO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MERGETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::mergeTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::CloneTo(IMedium *aTarget,
                                 ComSafeArrayIn(MediumVariant_T, aVariant),
                                 IMedium *aParent,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aVariant=%zu aParent=%p aProgress=%p\n", this, "Medium::cloneTo", aTarget, aVariant, aParent, 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<IMedium> TmpTarget(aTarget);
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        ComTypeInConverter<IMedium> TmpParent(aParent);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETO_ENTER(this, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpParent.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cloneTo(TmpTarget.ptr(),
                          TmpVariant.array(),
                          TmpParent.ptr(),
                          TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpParent.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETO_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_MEDIUM_CLONETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::cloneTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::CloneToBase(IMedium *aTarget,
                                     ComSafeArrayIn(MediumVariant_T, aVariant),
                                     IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aVariant=%zu aProgress=%p\n", this, "Medium::cloneToBase", aTarget, aVariant, 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<IMedium> TmpTarget(aTarget);
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETOBASE_ENTER(this, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cloneToBase(TmpTarget.ptr(),
                              TmpVariant.array(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETOBASE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CLONETOBASE_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_MEDIUM_CLONETOBASE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::cloneToBase", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::MoveTo(IN_BSTR aLocation,
                                IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aLocation=%ls aProgress=%p\n", this, "Medium::moveTo", aLocation, 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 TmpLocation(aLocation);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MOVETO_ENTER(this, TmpLocation.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = moveTo(autoCaller,
                     TmpLocation.str(),
                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MOVETO_RETURN(this, hrc, 0 /*normal*/, TmpLocation.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MOVETO_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_MOVETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::moveTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::Compact(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Medium::compact", 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_MEDIUM_COMPACT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = compact(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_COMPACT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_COMPACT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_COMPACT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::compact", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::Resize(LONG64 aLogicalSize,
                                IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aLogicalSize=%RI64 aProgress=%p\n", this, "Medium::resize", aLogicalSize, 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_MEDIUM_RESIZE_ENTER(this, aLogicalSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resize(aLogicalSize,
                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZE_RETURN(this, hrc, 0 /*normal*/, aLogicalSize, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZE_RETURN(this, hrc, 1 /*hrc exception*/, aLogicalSize, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZE_RETURN(this, hrc, 9 /*unhandled exception*/, aLogicalSize, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::resize", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::Reset(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "Medium::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_MEDIUM_RESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reset(autoCaller,
                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESET_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESET_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESET_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::reset", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::ChangeEncryption(IN_BSTR aCurrentPassword,
                                          IN_BSTR aCipher,
                                          IN_BSTR aNewPassword,
                                          IN_BSTR aNewPasswordId,
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aCurrentPassword=%ls aCipher=%ls aNewPassword=%ls aNewPasswordId=%ls aProgress=%p\n", this, "Medium::changeEncryption", aCurrentPassword, aCipher, aNewPassword, aNewPasswordId, 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_MEDIUM_CHANGEENCRYPTION_ENTER(this, TmpCurrentPassword.str().c_str(), TmpCipher.str().c_str(), TmpNewPassword.str().c_str(), TmpNewPasswordId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = changeEncryption(TmpCurrentPassword.str(),
                                   TmpCipher.str(),
                                   TmpNewPassword.str(),
                                   TmpNewPasswordId.str(),
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CHANGEENCRYPTION_RETURN(this, hrc, 0 /*normal*/, TmpCurrentPassword.str().c_str(), TmpCipher.str().c_str(), TmpNewPassword.str().c_str(), TmpNewPasswordId.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CHANGEENCRYPTION_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_MEDIUM_CHANGEENCRYPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::changeEncryption", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::GetEncryptionSettings(BSTR *aCipher,
                                               BSTR *aPasswordId)
{
    LogRelFlow(("{%p} %s: enter aCipher=%p aPasswordId=%p\n", this, "Medium::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_MEDIUM_GETENCRYPTIONSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEncryptionSettings(autoCaller,
                                    TmpCipher.str(),
                                        TmpPasswordId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_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_MEDIUM_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_MEDIUM_GETENCRYPTIONSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCipher=%ls aPasswordId=%ls hrc=%Rhrc\n", this, "Medium::getEncryptionSettings", !RT_VALID_PTR(aCipher) ? 0 : *aCipher, !RT_VALID_PTR(aPasswordId) ? 0 : *aPasswordId, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::CheckEncryptionPassword(IN_BSTR aPassword)
{
    LogRelFlow(("{%p} %s: enter aPassword=%ls\n", this, "Medium::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_MEDIUM_CHECKENCRYPTIONPASSWORD_ENTER(this, TmpPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = checkEncryptionPassword(TmpPassword.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpPassword.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_CHECKENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Medium::checkEncryptionPassword", hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::OpenForIO(BOOL aWritable,
                                   IN_BSTR aPassword,
                                   IMediumIO **aMediumIO)
{
    LogRelFlow(("{%p} %s: enter aWritable=%RTbool aPassword=%ls aMediumIO=%p\n", this, "Medium::openForIO", aWritable, aPassword, aMediumIO));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMediumIO);


        
        BSTRInConverter TmpPassword(aPassword);
        ComTypeOutConverter<IMediumIO> TmpMediumIO(aMediumIO);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_OPENFORIO_ENTER(this, aWritable != FALSE, TmpPassword.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = openForIO(aWritable != FALSE,
                            TmpPassword.str(),
                            TmpMediumIO.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_OPENFORIO_RETURN(this, hrc, 0 /*normal*/, aWritable != FALSE, TmpPassword.str().c_str(), (void *)TmpMediumIO.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_OPENFORIO_RETURN(this, hrc, 1 /*hrc exception*/, aWritable != FALSE, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_OPENFORIO_RETURN(this, hrc, 9 /*unhandled exception*/, aWritable != FALSE, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMediumIO=%p hrc=%Rhrc\n", this, "Medium::openForIO", !RT_VALID_PTR(aMediumIO) ? 0 : *aMediumIO, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::ResizeAndCloneTo(IMedium *aTarget,
                                          LONG64 aLogicalSize,
                                          ComSafeArrayIn(MediumVariant_T, aVariant),
                                          IMedium *aParent,
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTarget=%p aLogicalSize=%RI64 aVariant=%zu aParent=%p aProgress=%p\n", this, "Medium::resizeAndCloneTo", aTarget, aLogicalSize, aVariant, aParent, 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<IMedium> TmpTarget(aTarget);
        
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        ComTypeInConverter<IMedium> TmpParent(aParent);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZEANDCLONETO_ENTER(this, (void *)TmpTarget.ptr(), aLogicalSize, (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpParent.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resizeAndCloneTo(TmpTarget.ptr(),
                                   aLogicalSize,
                                   TmpVariant.array(),
                                   TmpParent.ptr(),
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZEANDCLONETO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpTarget.ptr(), aLogicalSize, (uint32_t)TmpVariant.array().size(), NULL /*for now*/, (void *)TmpParent.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZEANDCLONETO_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLogicalSize, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUM_RESIZEANDCLONETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLogicalSize, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "Medium::resizeAndCloneTo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod1IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod2IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod3IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod4IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod5IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod6IMedium()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumWrap::InternalAndReservedMethod7IMedium()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumWrap, IMedium)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumWrap.cpp"


// ##### BEGINFILE "MediumFormatWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMediumFormat.
 *
 * 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_MEDIUMFORMAT

#include "MediumFormatWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumFormatWrap)

//
// IMediumFormat properties
//

STDMETHODIMP MediumFormatWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "MediumFormat::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_MEDIUMFORMAT_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_MEDIUMFORMAT_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_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_MEDIUMFORMAT_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "MediumFormat::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "MediumFormat::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_MEDIUMFORMAT_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_MEDIUMFORMAT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_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_MEDIUMFORMAT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "MediumFormat::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(Capabilities)(ComSafeArrayOut(MediumFormatCapabilities_T, aCapabilities))
{
    LogRelFlow(("{%p} %s: enter aCapabilities=%p\n", this, "MediumFormat::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<MediumFormatCapabilities_T> TmpCapabilities(ComSafeArrayOutArg(aCapabilities));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_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_MEDIUMFORMAT_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_MEDIUMFORMAT_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_MEDIUMFORMAT_GET_CAPABILITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCapabilities=%zu hrc=%Rhrc\n", this, "MediumFormat::getCapabilities", !RT_VALID_PTR(aCapabilities) ? 0 : ComSafeArraySize(*aCapabilities), hrc));
    return hrc;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(InternalAndReservedAttribute1IMediumFormat)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(InternalAndReservedAttribute2IMediumFormat)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(InternalAndReservedAttribute3IMediumFormat)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumFormatWrap::COMGETTER(InternalAndReservedAttribute4IMediumFormat)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMediumFormat methods
//

STDMETHODIMP MediumFormatWrap::DescribeFileExtensions(ComSafeArrayOut(BSTR, aExtensions),
                                                      ComSafeArrayOut(DeviceType_T, aTypes))
{
    LogRelFlow(("{%p} %s: enter aExtensions=%p aTypes=%p\n", this, "MediumFormat::describeFileExtensions", aExtensions, aTypes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtensions);
        CheckComArgOutPointerValidThrow(aTypes);


        ArrayBSTROutConverter TmpExtensions(ComSafeArrayOutArg(aExtensions));
        ArrayOutConverter<DeviceType_T> TmpTypes(ComSafeArrayOutArg(aTypes));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEFILEEXTENSIONS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = describeFileExtensions(TmpExtensions.array(),
                                         TmpTypes.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEFILEEXTENSIONS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpExtensions.array().size(), NULL /*for now*/, (uint32_t)TmpTypes.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEFILEEXTENSIONS_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_MEDIUMFORMAT_DESCRIBEFILEEXTENSIONS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtensions=%zu *aTypes=%zu hrc=%Rhrc\n", this, "MediumFormat::describeFileExtensions", !RT_VALID_PTR(aExtensions) ? 0 : ComSafeArraySize(*aExtensions), !RT_VALID_PTR(aTypes) ? 0 : ComSafeArraySize(*aTypes), hrc));
    return hrc;
}

STDMETHODIMP MediumFormatWrap::DescribeProperties(ComSafeArrayOut(BSTR, aNames),
                                                  ComSafeArrayOut(BSTR, aDescriptions),
                                                  ComSafeArrayOut(DataType_T, aTypes),
                                                  ComSafeArrayOut(ULONG, aFlags),
                                                  ComSafeArrayOut(BSTR, aDefaults))
{
    LogRelFlow(("{%p} %s: enter aNames=%p aDescriptions=%p aTypes=%p aFlags=%p aDefaults=%p\n", this, "MediumFormat::describeProperties", aNames, aDescriptions, aTypes, aFlags, aDefaults));

    // Clear error 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(aDescriptions);
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aFlags);
        CheckComArgOutPointerValidThrow(aDefaults);


        ArrayBSTROutConverter TmpNames(ComSafeArrayOutArg(aNames));
        ArrayBSTROutConverter TmpDescriptions(ComSafeArrayOutArg(aDescriptions));
        ArrayOutConverter<DataType_T> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayOutConverter<ULONG> TmpFlags(ComSafeArrayOutArg(aFlags));
        ArrayBSTROutConverter TmpDefaults(ComSafeArrayOutArg(aDefaults));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEPROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = describeProperties(TmpNames.array(),
                                     TmpDescriptions.array(),
                                     TmpTypes.array(),
                                     TmpFlags.array(),
                                     TmpDefaults.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEPROPERTIES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpNames.array().size(), NULL /*for now*/, (uint32_t)TmpDescriptions.array().size(), NULL /*for now*/, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (uint32_t)TmpDefaults.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMFORMAT_DESCRIBEPROPERTIES_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_MEDIUMFORMAT_DESCRIBEPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNames=%zu *aDescriptions=%zu *aTypes=%zu *aFlags=%zu *aDefaults=%zu hrc=%Rhrc\n", this, "MediumFormat::describeProperties", !RT_VALID_PTR(aNames) ? 0 : ComSafeArraySize(*aNames), !RT_VALID_PTR(aDescriptions) ? 0 : ComSafeArraySize(*aDescriptions), !RT_VALID_PTR(aTypes) ? 0 : ComSafeArraySize(*aTypes), !RT_VALID_PTR(aFlags) ? 0 : ComSafeArraySize(*aFlags), !RT_VALID_PTR(aDefaults) ? 0 : ComSafeArraySize(*aDefaults), hrc));
    return hrc;
}

STDMETHODIMP MediumFormatWrap::InternalAndReservedMethod1IMediumFormat()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumFormatWrap::InternalAndReservedMethod2IMediumFormat()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumFormatWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumFormatWrap, IMediumFormat)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumFormatWrap.cpp"


// ##### BEGINFILE "TokenWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IToken.
 *
 * 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_TOKEN

#include "TokenWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(TokenWrap)

//
// IToken properties
//

STDMETHODIMP TokenWrap::COMGETTER(InternalAndReservedAttribute1IToken)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP TokenWrap::COMGETTER(InternalAndReservedAttribute2IToken)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IToken methods
//

STDMETHODIMP TokenWrap::Abandon()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Token::abandon"));

    // Clear 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_TOKEN_ABANDON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = abandon(autoCaller);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_ABANDON_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_ABANDON_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_ABANDON_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Token::abandon", hrc));
    return hrc;
}

STDMETHODIMP TokenWrap::Dummy()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Token::dummy"));

    // Clear 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_TOKEN_DUMMY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = dummy();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_DUMMY_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_DUMMY_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_TOKEN_DUMMY_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Token::dummy", hrc));
    return hrc;
}

STDMETHODIMP TokenWrap::InternalAndReservedMethod1IToken()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(TokenWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(TokenWrap, IToken)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "TokenWrap.cpp"


// ##### BEGINFILE "KeyboardWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IKeyboard.
 *
 * 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_KEYBOARD

#include "KeyboardWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(KeyboardWrap)

//
// IKeyboard properties
//

STDMETHODIMP KeyboardWrap::COMGETTER(KeyboardLEDs)(ComSafeArrayOut(KeyboardLED_T, aKeyboardLEDs))
{
    LogRelFlow(("{%p} %s: enter aKeyboardLEDs=%p\n", this, "Keyboard::getKeyboardLEDs", aKeyboardLEDs));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyboardLEDs);
        ArrayOutConverter<KeyboardLED_T> TmpKeyboardLEDs(ComSafeArrayOutArg(aKeyboardLEDs));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_GET_KEYBOARDLEDS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyboardLEDs(TmpKeyboardLEDs.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_GET_KEYBOARDLEDS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpKeyboardLEDs.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_GET_KEYBOARDLEDS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_GET_KEYBOARDLEDS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyboardLEDs=%zu hrc=%Rhrc\n", this, "Keyboard::getKeyboardLEDs", !RT_VALID_PTR(aKeyboardLEDs) ? 0 : ComSafeArraySize(*aKeyboardLEDs), hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Keyboard::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_KEYBOARD_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_KEYBOARD_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_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_KEYBOARD_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Keyboard::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::COMGETTER(InternalAndReservedAttribute1IKeyboard)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::COMGETTER(InternalAndReservedAttribute2IKeyboard)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::COMGETTER(InternalAndReservedAttribute3IKeyboard)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::COMGETTER(InternalAndReservedAttribute4IKeyboard)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IKeyboard methods
//

STDMETHODIMP KeyboardWrap::PutScancode(LONG aScancode)
{
    LogRelFlow(("{%p} %s: enter aScancode=%RI32\n", this, "Keyboard::putScancode", aScancode));

    // Clear 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_KEYBOARD_PUTSCANCODE_ENTER(this, aScancode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putScancode(aScancode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODE_RETURN(this, hrc, 0 /*normal*/, aScancode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODE_RETURN(this, hrc, 1 /*hrc exception*/, aScancode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODE_RETURN(this, hrc, 9 /*unhandled exception*/, aScancode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Keyboard::putScancode", hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::PutScancodes(ComSafeArrayIn(LONG, aScancodes),
                                        ULONG *aCodesStored)
{
    LogRelFlow(("{%p} %s: enter aScancodes=%zu aCodesStored=%p\n", this, "Keyboard::putScancodes", aScancodes, aCodesStored));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCodesStored);


        ArrayInConverter<LONG> TmpScancodes(ComSafeArrayInArg(aScancodes));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODES_ENTER(this, (uint32_t)TmpScancodes.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putScancodes(TmpScancodes.array(),
                               aCodesStored);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpScancodes.array().size(), NULL /*for now*/, *aCodesStored);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, *aCodesStored);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTSCANCODES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, *aCodesStored);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCodesStored=%RU32 hrc=%Rhrc\n", this, "Keyboard::putScancodes", !RT_VALID_PTR(aCodesStored) ? 0 : *aCodesStored, hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::PutCAD()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Keyboard::putCAD"));

    // Clear 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_KEYBOARD_PUTCAD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putCAD();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTCAD_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTCAD_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTCAD_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Keyboard::putCAD", hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::ReleaseKeys()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Keyboard::releaseKeys"));

    // Clear 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_KEYBOARD_RELEASEKEYS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = releaseKeys();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_RELEASEKEYS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_RELEASEKEYS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_RELEASEKEYS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Keyboard::releaseKeys", hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::PutUsageCode(LONG aUsageCode,
                                        LONG aUsagePage,
                                        BOOL aKeyRelease)
{
    LogRelFlow(("{%p} %s: enter aUsageCode=%RI32 aUsagePage=%RI32 aKeyRelease=%RTbool\n", this, "Keyboard::putUsageCode", aUsageCode, aUsagePage, aKeyRelease));

    // Clear 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_KEYBOARD_PUTUSAGECODE_ENTER(this, aUsageCode, aUsagePage, aKeyRelease != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putUsageCode(aUsageCode,
                               aUsagePage,
                               aKeyRelease != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTUSAGECODE_RETURN(this, hrc, 0 /*normal*/, aUsageCode, aUsagePage, aKeyRelease != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTUSAGECODE_RETURN(this, hrc, 1 /*hrc exception*/, aUsageCode, aUsagePage, aKeyRelease != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_KEYBOARD_PUTUSAGECODE_RETURN(this, hrc, 9 /*unhandled exception*/, aUsageCode, aUsagePage, aKeyRelease != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Keyboard::putUsageCode", hrc));
    return hrc;
}

STDMETHODIMP KeyboardWrap::InternalAndReservedMethod1IKeyboard()
{
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::InternalAndReservedMethod2IKeyboard()
{
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::InternalAndReservedMethod3IKeyboard()
{
    return E_NOTIMPL;
}

STDMETHODIMP KeyboardWrap::InternalAndReservedMethod4IKeyboard()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(KeyboardWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(KeyboardWrap, IKeyboard)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "KeyboardWrap.cpp"


// ##### BEGINFILE "MouseWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMouse.
 *
 * 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_MOUSE

#include "MouseWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MouseWrap)

//
// IMouse properties
//

STDMETHODIMP MouseWrap::COMGETTER(AbsoluteSupported)(BOOL *aAbsoluteSupported)
{
    LogRelFlow(("{%p} %s: enter aAbsoluteSupported=%p\n", this, "Mouse::getAbsoluteSupported", aAbsoluteSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAbsoluteSupported);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_ABSOLUTESUPPORTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAbsoluteSupported(aAbsoluteSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_ABSOLUTESUPPORTED_RETURN(this, hrc, 0 /*normal*/,*aAbsoluteSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_ABSOLUTESUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/,*aAbsoluteSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_ABSOLUTESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aAbsoluteSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAbsoluteSupported=%RTbool hrc=%Rhrc\n", this, "Mouse::getAbsoluteSupported", !RT_VALID_PTR(aAbsoluteSupported) ? 0 : *aAbsoluteSupported, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(RelativeSupported)(BOOL *aRelativeSupported)
{
    LogRelFlow(("{%p} %s: enter aRelativeSupported=%p\n", this, "Mouse::getRelativeSupported", aRelativeSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRelativeSupported);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_RELATIVESUPPORTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRelativeSupported(aRelativeSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_RELATIVESUPPORTED_RETURN(this, hrc, 0 /*normal*/,*aRelativeSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_RELATIVESUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/,*aRelativeSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_RELATIVESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aRelativeSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRelativeSupported=%RTbool hrc=%Rhrc\n", this, "Mouse::getRelativeSupported", !RT_VALID_PTR(aRelativeSupported) ? 0 : *aRelativeSupported, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(TouchScreenSupported)(BOOL *aTouchScreenSupported)
{
    LogRelFlow(("{%p} %s: enter aTouchScreenSupported=%p\n", this, "Mouse::getTouchScreenSupported", aTouchScreenSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTouchScreenSupported);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHSCREENSUPPORTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTouchScreenSupported(aTouchScreenSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHSCREENSUPPORTED_RETURN(this, hrc, 0 /*normal*/,*aTouchScreenSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHSCREENSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/,*aTouchScreenSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHSCREENSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTouchScreenSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTouchScreenSupported=%RTbool hrc=%Rhrc\n", this, "Mouse::getTouchScreenSupported", !RT_VALID_PTR(aTouchScreenSupported) ? 0 : *aTouchScreenSupported, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(TouchPadSupported)(BOOL *aTouchPadSupported)
{
    LogRelFlow(("{%p} %s: enter aTouchPadSupported=%p\n", this, "Mouse::getTouchPadSupported", aTouchPadSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTouchPadSupported);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHPADSUPPORTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTouchPadSupported(aTouchPadSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHPADSUPPORTED_RETURN(this, hrc, 0 /*normal*/,*aTouchPadSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHPADSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/,*aTouchPadSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_TOUCHPADSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTouchPadSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTouchPadSupported=%RTbool hrc=%Rhrc\n", this, "Mouse::getTouchPadSupported", !RT_VALID_PTR(aTouchPadSupported) ? 0 : *aTouchPadSupported, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(NeedsHostCursor)(BOOL *aNeedsHostCursor)
{
    LogRelFlow(("{%p} %s: enter aNeedsHostCursor=%p\n", this, "Mouse::getNeedsHostCursor", aNeedsHostCursor));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNeedsHostCursor);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_NEEDSHOSTCURSOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNeedsHostCursor(aNeedsHostCursor);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_NEEDSHOSTCURSOR_RETURN(this, hrc, 0 /*normal*/,*aNeedsHostCursor != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_NEEDSHOSTCURSOR_RETURN(this, hrc, 1 /*hrc exception*/,*aNeedsHostCursor != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_NEEDSHOSTCURSOR_RETURN(this, hrc, 9 /*unhandled exception*/,*aNeedsHostCursor != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNeedsHostCursor=%RTbool hrc=%Rhrc\n", this, "Mouse::getNeedsHostCursor", !RT_VALID_PTR(aNeedsHostCursor) ? 0 : *aNeedsHostCursor, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(PointerShape)(IMousePointerShape **aPointerShape)
{
    LogRelFlow(("{%p} %s: enter aPointerShape=%p\n", this, "Mouse::getPointerShape", aPointerShape));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPointerShape);
        ComTypeOutConverter<IMousePointerShape> TmpPointerShape(aPointerShape);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_POINTERSHAPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPointerShape(TmpPointerShape.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_POINTERSHAPE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpPointerShape.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_POINTERSHAPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_GET_POINTERSHAPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPointerShape=%p hrc=%Rhrc\n", this, "Mouse::getPointerShape", !RT_VALID_PTR(aPointerShape) ? 0 : *aPointerShape, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Mouse::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_MOUSE_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_MOUSE_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_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_MOUSE_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Mouse::getEventSource", !RT_VALID_PTR(aEventSource) ? 0 : *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::COMGETTER(InternalAndReservedAttribute1IMouse)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::COMGETTER(InternalAndReservedAttribute2IMouse)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::COMGETTER(InternalAndReservedAttribute3IMouse)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::COMGETTER(InternalAndReservedAttribute4IMouse)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMouse methods
//

STDMETHODIMP MouseWrap::PutMouseEvent(LONG aDx,
                                      LONG aDy,
                                      LONG aDz,
                                      LONG aDw,
                                      LONG aButtonState)
{
    LogRelFlow(("{%p} %s: enter aDx=%RI32 aDy=%RI32 aDz=%RI32 aDw=%RI32 aButtonState=%RI32\n", this, "Mouse::putMouseEvent", aDx, aDy, aDz, aDw, aButtonState));

    // Clear 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_MOUSE_PUTMOUSEEVENT_ENTER(this, aDx, aDy, aDz, aDw, aButtonState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putMouseEvent(aDx,
                                aDy,
                                aDz,
                                aDw,
                                aButtonState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENT_RETURN(this, hrc, 0 /*normal*/, aDx, aDy, aDz, aDw, aButtonState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENT_RETURN(this, hrc, 1 /*hrc exception*/, aDx, aDy, aDz, aDw, aButtonState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, aDx, aDy, aDz, aDw, aButtonState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Mouse::putMouseEvent", hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::PutMouseEventAbsolute(LONG aX,
                                              LONG aY,
                                              LONG aDz,
                                              LONG aDw,
                                              LONG aButtonState)
{
    LogRelFlow(("{%p} %s: enter aX=%RI32 aY=%RI32 aDz=%RI32 aDw=%RI32 aButtonState=%RI32\n", this, "Mouse::putMouseEventAbsolute", aX, aY, aDz, aDw, aButtonState));

    // Clear 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_MOUSE_PUTMOUSEEVENTABSOLUTE_ENTER(this, aX, aY, aDz, aDw, aButtonState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putMouseEventAbsolute(aX,
                                        aY,
                                        aDz,
                                        aDw,
                                        aButtonState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENTABSOLUTE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aDz, aDw, aButtonState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENTABSOLUTE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY, aDz, aDw, aButtonState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTMOUSEEVENTABSOLUTE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aDz, aDw, aButtonState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Mouse::putMouseEventAbsolute", hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::PutEventMultiTouch(LONG aCount,
                                           ComSafeArrayIn(LONG64, aContacts),
                                           BOOL aIsTouchScreen,
                                           ULONG aScanTime)
{
    LogRelFlow(("{%p} %s: enter aCount=%RI32 aContacts=%zu aIsTouchScreen=%RTbool aScanTime=%RU32\n", this, "Mouse::putEventMultiTouch", aCount, aContacts, aIsTouchScreen, aScanTime));

    // Clear 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<LONG64> TmpContacts(ComSafeArrayInArg(aContacts));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCH_ENTER(this, aCount, (uint32_t)TmpContacts.array().size(), NULL /*for now*/, aIsTouchScreen != FALSE, aScanTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putEventMultiTouch(aCount,
                                     TmpContacts.array(),
                                     aIsTouchScreen != FALSE,
                                     aScanTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCH_RETURN(this, hrc, 0 /*normal*/, aCount, (uint32_t)TmpContacts.array().size(), NULL /*for now*/, aIsTouchScreen != FALSE, aScanTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCH_RETURN(this, hrc, 1 /*hrc exception*/, aCount, 0, 0, aIsTouchScreen != FALSE, aScanTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCH_RETURN(this, hrc, 9 /*unhandled exception*/, aCount, 0, 0, aIsTouchScreen != FALSE, aScanTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Mouse::putEventMultiTouch", hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::PutEventMultiTouchString(LONG aCount,
                                                 IN_BSTR aContacts,
                                                 BOOL aIsTouchScreen,
                                                 ULONG aScanTime)
{
    LogRelFlow(("{%p} %s: enter aCount=%RI32 aContacts=%ls aIsTouchScreen=%RTbool aScanTime=%RU32\n", this, "Mouse::putEventMultiTouchString", aCount, aContacts, aIsTouchScreen, aScanTime));

    // Clear 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 TmpContacts(aContacts);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCHSTRING_ENTER(this, aCount, TmpContacts.str().c_str(), aIsTouchScreen != FALSE, aScanTime);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = putEventMultiTouchString(aCount,
                                           TmpContacts.str(),
                                           aIsTouchScreen != FALSE,
                                           aScanTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCHSTRING_RETURN(this, hrc, 0 /*normal*/, aCount, TmpContacts.str().c_str(), aIsTouchScreen != FALSE, aScanTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCHSTRING_RETURN(this, hrc, 1 /*hrc exception*/, aCount, 0, aIsTouchScreen != FALSE, aScanTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSE_PUTEVENTMULTITOUCHSTRING_RETURN(this, hrc, 9 /*unhandled exception*/, aCount, 0, aIsTouchScreen != FALSE, aScanTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Mouse::putEventMultiTouchString", hrc));
    return hrc;
}

STDMETHODIMP MouseWrap::InternalAndReservedMethod1IMouse()
{
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::InternalAndReservedMethod2IMouse()
{
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::InternalAndReservedMethod3IMouse()
{
    return E_NOTIMPL;
}

STDMETHODIMP MouseWrap::InternalAndReservedMethod4IMouse()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MouseWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MouseWrap, IMouse)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MouseWrap.cpp"


// ##### BEGINFILE "FramebufferOverlayWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFramebufferOverlay.
 *
 * 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_FRAMEBUFFEROVERLAY

#include "FramebufferOverlayWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FramebufferOverlayWrap)

//
// IFramebuffer properties
//

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getWidth", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getHeight", !RT_VALID_PTR(aHeight) ? 0 : *aHeight, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(BitsPerPixel)(ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aBitsPerPixel=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_BITSPERPIXEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBitsPerPixel(aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_BITSPERPIXEL_RETURN(this, hrc, 0 /*normal*/,*aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_BITSPERPIXEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getBitsPerPixel", !RT_VALID_PTR(aBitsPerPixel) ? 0 : *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(BytesPerLine)(ULONG *aBytesPerLine)
{
    LogRelFlow(("{%p} %s: enter aBytesPerLine=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_BYTESPERLINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesPerLine(aBytesPerLine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_BYTESPERLINE_RETURN(this, hrc, 0 /*normal*/,*aBytesPerLine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_BYTESPERLINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesPerLine);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesPerLine=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getBytesPerLine", !RT_VALID_PTR(aBytesPerLine) ? 0 : *aBytesPerLine, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(PixelFormat)(BitmapFormat_T *aPixelFormat)
{
    LogRelFlow(("{%p} %s: enter aPixelFormat=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_PIXELFORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPixelFormat(aPixelFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_PIXELFORMAT_RETURN(this, hrc, 0 /*normal*/,*aPixelFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_PIXELFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPixelFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPixelFormat=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getPixelFormat", !RT_VALID_PTR(aPixelFormat) ? 0 : *aPixelFormat, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(HeightReduction)(ULONG *aHeightReduction)
{
    LogRelFlow(("{%p} %s: enter aHeightReduction=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_HEIGHTREDUCTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeightReduction(aHeightReduction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_HEIGHTREDUCTION_RETURN(this, hrc, 0 /*normal*/,*aHeightReduction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_HEIGHTREDUCTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeightReduction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeightReduction=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getHeightReduction", !RT_VALID_PTR(aHeightReduction) ? 0 : *aHeightReduction, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Overlay)(IFramebufferOverlay **aOverlay)
{
    LogRelFlow(("{%p} %s: enter aOverlay=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_OVERLAY_RETURN(this, hrc, 0 /*normal*/,(void *)TmpOverlay.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_OVERLAY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOverlay=%p hrc=%Rhrc\n", this, "FramebufferOverlay::getOverlay", !RT_VALID_PTR(aOverlay) ? 0 : *aOverlay, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(WinId)(LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s: enter aWinId=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_WINID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWinId(aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_WINID_RETURN(this, hrc, 0 /*normal*/,*aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_WINID_RETURN(this, hrc, 9 /*unhandled exception*/,*aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWinId=%RI64 hrc=%Rhrc\n", this, "FramebufferOverlay::getWinId", !RT_VALID_PTR(aWinId) ? 0 : *aWinId, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Capabilities)(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities))
{
    LogRelFlow(("{%p} %s: enter aCapabilities=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_CAPABILITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCapabilities=%zu hrc=%Rhrc\n", this, "FramebufferOverlay::getCapabilities", !RT_VALID_PTR(aCapabilities) ? 0 : ComSafeArraySize(*aCapabilities), hrc));
    return hrc;
}

//
// IFramebufferOverlay properties
//

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(X)(ULONG *aX)
{
    LogRelFlow(("{%p} %s: enter aX=%p\n", this, "FramebufferOverlay::getX", aX));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aX);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_X_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getX(aX);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_X_RETURN(this, hrc, 0 /*normal*/,*aX);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_X_RETURN(this, hrc, 1 /*hrc exception*/,*aX);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_X_RETURN(this, hrc, 9 /*unhandled exception*/,*aX);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aX=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getX", !RT_VALID_PTR(aX) ? 0 : *aX, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Y)(ULONG *aY)
{
    LogRelFlow(("{%p} %s: enter aY=%p\n", this, "FramebufferOverlay::getY", aY));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aY);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_Y_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getY(aY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_Y_RETURN(this, hrc, 0 /*normal*/,*aY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_Y_RETURN(this, hrc, 1 /*hrc exception*/,*aY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_Y_RETURN(this, hrc, 9 /*unhandled exception*/,*aY);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aY=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getY", !RT_VALID_PTR(aY) ? 0 : *aY, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "FramebufferOverlay::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMSETTER(Visible)(BOOL aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%RTbool\n", this, "FramebufferOverlay::setVisible", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_VISIBLE_ENTER(this, aVisible != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVisible(aVisible != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_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_FRAMEBUFFEROVERLAY_SET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::setVisible", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMGETTER(Alpha)(ULONG *aAlpha)
{
    LogRelFlow(("{%p} %s: enter aAlpha=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_GET_ALPHA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAlpha(aAlpha);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_ALPHA_RETURN(this, hrc, 0 /*normal*/,*aAlpha);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_ALPHA_RETURN(this, hrc, 1 /*hrc exception*/,*aAlpha);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_GET_ALPHA_RETURN(this, hrc, 9 /*unhandled exception*/,*aAlpha);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAlpha=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getAlpha", !RT_VALID_PTR(aAlpha) ? 0 : *aAlpha, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::COMSETTER(Alpha)(ULONG aAlpha)
{
    LogRelFlow(("{%p} %s: enter aAlpha=%RU32\n", this, "FramebufferOverlay::setAlpha", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_ALPHA_ENTER(this, aAlpha);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAlpha(aAlpha);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_ALPHA_RETURN(this, hrc, 0 /*normal*/,aAlpha);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_ALPHA_RETURN(this, hrc, 1 /*hrc exception*/,aAlpha);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_SET_ALPHA_RETURN(this, hrc, 9 /*unhandled exception*/,aAlpha);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::setAlpha", hrc));
    return hrc;
}


//
// IFramebuffer methods
//

STDMETHODIMP FramebufferOverlayWrap::NotifyUpdate(ULONG aX,
                                                  ULONG aY,
                                                  ULONG aWidth,
                                                  ULONG aHeight)
{
    LogRelFlow(("{%p} %s: enter aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFYUPDATE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFYUPDATE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::notifyUpdate", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::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, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::notifyUpdateImage", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::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, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFYCHANGE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::notifyChange", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::VideoModeSupported(ULONG aWidth,
                                                        ULONG aHeight,
                                                        ULONG aBpp,
                                                        BOOL *aSupported)
{
    LogRelFlow(("{%p} %s: enter aWidth=%RU32 aHeight=%RU32 aBpp=%RU32 aSupported=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_VIDEOMODESUPPORTED_RETURN(this, hrc, 0 /*normal*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_VIDEOMODESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "FramebufferOverlay::videoModeSupported", !RT_VALID_PTR(aSupported) ? 0 : *aSupported, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::GetVisibleRegion(BYTE *aRectangles,
                                                      ULONG aCount,
                                                      ULONG *aCountCopied)
{
    LogRelFlow(("{%p} %s: enter aRectangles=%p aCount=%RU32 aCountCopied=%p\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount, *aCountCopied);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_GETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount, *aCountCopied);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCountCopied=%RU32 hrc=%Rhrc\n", this, "FramebufferOverlay::getVisibleRegion", !RT_VALID_PTR(aCountCopied) ? 0 : *aCountCopied, hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::SetVisibleRegion(BYTE *aRectangles,
                                                      ULONG aCount)
{
    LogRelFlow(("{%p} %s: enter aRectangles=%p aCount=%RU32\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_SETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_SETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::setVisibleRegion", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::ProcessVHWACommand(BYTE *aCommand,
                                                        LONG aEnmCmd,
                                                        BOOL aFromGuest)
{
    LogRelFlow(("{%p} %s: enter aCommand=%p aEnmCmd=%RI32 aFromGuest=%RTbool\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_PROCESSVHWACOMMAND_RETURN(this, hrc, 0 /*normal*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_PROCESSVHWACOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::processVHWACommand", hrc));
    return hrc;
}

STDMETHODIMP FramebufferOverlayWrap::Notify3DEvent(ULONG aType,
                                                   ComSafeArrayIn(BYTE, aData))
{
    LogRelFlow(("{%p} %s: enter aType=%RU32 aData=%zu\n", this, "FramebufferOverlay::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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_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_FRAMEBUFFEROVERLAY_NOTIFY3DEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::notify3DEvent", hrc));
    return hrc;
}

//
// IFramebufferOverlay methods
//

STDMETHODIMP FramebufferOverlayWrap::Move(ULONG aX,
                                          ULONG aY)
{
    LogRelFlow(("{%p} %s: enter aX=%RU32 aY=%RU32\n", this, "FramebufferOverlay::move", aX, aY));

    // Clear 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_FRAMEBUFFEROVERLAY_MOVE_ENTER(this, aX, aY);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = move(aX,
                       aY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_MOVE_RETURN(this, hrc, 0 /*normal*/, aX, aY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_MOVE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFEROVERLAY_MOVE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "FramebufferOverlay::move", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FramebufferOverlayWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(FramebufferOverlayWrap, IFramebufferOverlay, IFramebuffer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FramebufferOverlayWrap.cpp"


// ##### BEGINFILE "DisplayWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDisplay.
 *
 * 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_DISPLAY

#include "DisplayWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DisplayWrap)

//
// IDisplay properties
//

STDMETHODIMP DisplayWrap::COMGETTER(GuestScreenLayout)(ComSafeArrayOut(IGuestScreenInfo *, aGuestScreenLayout))
{
    LogRelFlow(("{%p} %s: enter aGuestScreenLayout=%p\n", this, "Display::getGuestScreenLayout", aGuestScreenLayout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestScreenLayout);
        ArrayComTypeOutConverter<IGuestScreenInfo> TmpGuestScreenLayout(ComSafeArrayOutArg(aGuestScreenLayout));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GET_GUESTSCREENLAYOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestScreenLayout(TmpGuestScreenLayout.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GET_GUESTSCREENLAYOUT_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpGuestScreenLayout.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GET_GUESTSCREENLAYOUT_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GET_GUESTSCREENLAYOUT_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestScreenLayout=%zu hrc=%Rhrc\n", this, "Display::getGuestScreenLayout", !RT_VALID_PTR(aGuestScreenLayout) ? 0 : ComSafeArraySize(*aGuestScreenLayout), hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute1IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute2IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute3IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute4IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute5IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute6IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute7IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute8IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute9IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute10IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute11IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute12IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute13IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute14IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute15IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::COMGETTER(InternalAndReservedAttribute16IDisplay)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IEventListener properties
//


//
// IDisplay methods
//

STDMETHODIMP DisplayWrap::GetScreenResolution(ULONG aScreenId,
                                              ULONG *aWidth,
                                              ULONG *aHeight,
                                              ULONG *aBitsPerPixel,
                                              LONG *aXOrigin,
                                              LONG *aYOrigin,
                                              GuestMonitorStatus_T *aGuestMonitorStatus)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aWidth=%p aHeight=%p aBitsPerPixel=%p aXOrigin=%p aYOrigin=%p aGuestMonitorStatus=%p\n", this, "Display::getScreenResolution", aScreenId, aWidth, aHeight, aBitsPerPixel, aXOrigin, aYOrigin, 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(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        CheckComArgOutPointerValidThrow(aXOrigin);
        CheckComArgOutPointerValidThrow(aYOrigin);
        CheckComArgOutPointerValidThrow(aGuestMonitorStatus);


        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETSCREENRESOLUTION_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenResolution(aScreenId,
                                      aWidth,
                                      aHeight,
                                      aBitsPerPixel,
                                      aXOrigin,
                                      aYOrigin,
                                      aGuestMonitorStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETSCREENRESOLUTION_RETURN(this, hrc, 0 /*normal*/, aScreenId, *aWidth, *aHeight, *aBitsPerPixel, *aXOrigin, *aYOrigin, *aGuestMonitorStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETSCREENRESOLUTION_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, *aWidth, *aHeight, *aBitsPerPixel, *aXOrigin, *aYOrigin, *aGuestMonitorStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETSCREENRESOLUTION_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, *aWidth, *aHeight, *aBitsPerPixel, *aXOrigin, *aYOrigin, *aGuestMonitorStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 *aHeight=%RU32 *aBitsPerPixel=%RU32 *aXOrigin=%RI32 *aYOrigin=%RI32 *aGuestMonitorStatus=%RU32 hrc=%Rhrc\n", this, "Display::getScreenResolution", !RT_VALID_PTR(aWidth) ? 0 : *aWidth, !RT_VALID_PTR(aHeight) ? 0 : *aHeight, !RT_VALID_PTR(aBitsPerPixel) ? 0 : *aBitsPerPixel, !RT_VALID_PTR(aXOrigin) ? 0 : *aXOrigin, !RT_VALID_PTR(aYOrigin) ? 0 : *aYOrigin, !RT_VALID_PTR(aGuestMonitorStatus) ? 0 : *aGuestMonitorStatus, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::AttachFramebuffer(ULONG aScreenId,
                                            IFramebuffer *aFramebuffer,
                                            BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aFramebuffer=%p aId=%p\n", this, "Display::attachFramebuffer", aScreenId, aFramebuffer, 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);


        
        ComTypeInConverter<IFramebuffer> TmpFramebuffer(aFramebuffer);
        UuidOutConverter TmpId(aId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_ATTACHFRAMEBUFFER_ENTER(this, aScreenId, (void *)TmpFramebuffer.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = attachFramebuffer(aScreenId,
                                    TmpFramebuffer.ptr(),
                                    TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_ATTACHFRAMEBUFFER_RETURN(this, hrc, 0 /*normal*/, aScreenId, (void *)TmpFramebuffer.ptr(), TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_ATTACHFRAMEBUFFER_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_ATTACHFRAMEBUFFER_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aId=%ls hrc=%Rhrc\n", this, "Display::attachFramebuffer", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::DetachFramebuffer(ULONG aScreenId,
                                            IN_BSTR aId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aId=%ls\n", this, "Display::detachFramebuffer", aScreenId, 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
    {


        
        UuidInConverter TmpId(aId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHFRAMEBUFFER_ENTER(this, aScreenId, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachFramebuffer(aScreenId,
                                    TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHFRAMEBUFFER_RETURN(this, hrc, 0 /*normal*/, aScreenId, TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHFRAMEBUFFER_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHFRAMEBUFFER_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::detachFramebuffer", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::QueryFramebuffer(ULONG aScreenId,
                                           IFramebuffer **aFramebuffer)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aFramebuffer=%p\n", this, "Display::queryFramebuffer", aScreenId, aFramebuffer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFramebuffer);


        
        ComTypeOutConverter<IFramebuffer> TmpFramebuffer(aFramebuffer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYFRAMEBUFFER_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryFramebuffer(aScreenId,
                                   TmpFramebuffer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYFRAMEBUFFER_RETURN(this, hrc, 0 /*normal*/, aScreenId, (void *)TmpFramebuffer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYFRAMEBUFFER_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYFRAMEBUFFER_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFramebuffer=%p hrc=%Rhrc\n", this, "Display::queryFramebuffer", !RT_VALID_PTR(aFramebuffer) ? 0 : *aFramebuffer, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::SetVideoModeHint(ULONG aDisplay,
                                           BOOL aEnabled,
                                           BOOL aChangeOrigin,
                                           LONG aOriginX,
                                           LONG aOriginY,
                                           ULONG aWidth,
                                           ULONG aHeight,
                                           ULONG aBitsPerPixel,
                                           BOOL aNotify)
{
    LogRelFlow(("{%p} %s: enter aDisplay=%RU32 aEnabled=%RTbool aChangeOrigin=%RTbool aOriginX=%RI32 aOriginY=%RI32 aWidth=%RU32 aHeight=%RU32 aBitsPerPixel=%RU32 aNotify=%RTbool\n", this, "Display::setVideoModeHint", aDisplay, aEnabled, aChangeOrigin, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aNotify));

    // Clear 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_DISPLAY_SETVIDEOMODEHINT_ENTER(this, aDisplay, aEnabled != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aNotify != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVideoModeHint(aDisplay,
                                   aEnabled != FALSE,
                                   aChangeOrigin != FALSE,
                                   aOriginX,
                                   aOriginY,
                                   aWidth,
                                   aHeight,
                                   aBitsPerPixel,
                                   aNotify != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETVIDEOMODEHINT_RETURN(this, hrc, 0 /*normal*/, aDisplay, aEnabled != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aNotify != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETVIDEOMODEHINT_RETURN(this, hrc, 1 /*hrc exception*/, aDisplay, aEnabled != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aNotify != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETVIDEOMODEHINT_RETURN(this, hrc, 9 /*unhandled exception*/, aDisplay, aEnabled != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aNotify != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::setVideoModeHint", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::GetVideoModeHint(ULONG aDisplay,
                                           BOOL *aEnabled,
                                           BOOL *aChangeOrigin,
                                           LONG *aOriginX,
                                           LONG *aOriginY,
                                           ULONG *aWidth,
                                           ULONG *aHeight,
                                           ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aDisplay=%RU32 aEnabled=%p aChangeOrigin=%p aOriginX=%p aOriginY=%p aWidth=%p aHeight=%p aBitsPerPixel=%p\n", this, "Display::getVideoModeHint", aDisplay, aEnabled, aChangeOrigin, aOriginX, aOriginY, aWidth, aHeight, 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(aEnabled);
        CheckComArgOutPointerValidThrow(aChangeOrigin);
        CheckComArgOutPointerValidThrow(aOriginX);
        CheckComArgOutPointerValidThrow(aOriginY);
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aBitsPerPixel);


        
        
        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETVIDEOMODEHINT_ENTER(this, aDisplay);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVideoModeHint(aDisplay,
                                   aEnabled,
                                   aChangeOrigin,
                                   aOriginX,
                                   aOriginY,
                                   aWidth,
                                   aHeight,
                                   aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETVIDEOMODEHINT_RETURN(this, hrc, 0 /*normal*/, aDisplay, *aEnabled != FALSE, *aChangeOrigin != FALSE, *aOriginX, *aOriginY, *aWidth, *aHeight, *aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETVIDEOMODEHINT_RETURN(this, hrc, 1 /*hrc exception*/, aDisplay, *aEnabled != FALSE, *aChangeOrigin != FALSE, *aOriginX, *aOriginY, *aWidth, *aHeight, *aBitsPerPixel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_GETVIDEOMODEHINT_RETURN(this, hrc, 9 /*unhandled exception*/, aDisplay, *aEnabled != FALSE, *aChangeOrigin != FALSE, *aOriginX, *aOriginY, *aWidth, *aHeight, *aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool *aChangeOrigin=%RTbool *aOriginX=%RI32 *aOriginY=%RI32 *aWidth=%RU32 *aHeight=%RU32 *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "Display::getVideoModeHint", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, !RT_VALID_PTR(aChangeOrigin) ? 0 : *aChangeOrigin, !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(aBitsPerPixel) ? 0 : *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::SetSeamlessMode(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "Display::setSeamlessMode", 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_DISPLAY_SETSEAMLESSMODE_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSeamlessMode(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSEAMLESSMODE_RETURN(this, hrc, 0 /*normal*/, aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSEAMLESSMODE_RETURN(this, hrc, 1 /*hrc exception*/, aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSEAMLESSMODE_RETURN(this, hrc, 9 /*unhandled exception*/, aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::setSeamlessMode", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::TakeScreenShot(ULONG aScreenId,
                                         BYTE *aAddress,
                                         ULONG aWidth,
                                         ULONG aHeight,
                                         BitmapFormat_T aBitmapFormat)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aAddress=%p aWidth=%RU32 aHeight=%RU32 aBitmapFormat=%RU32\n", this, "Display::takeScreenShot", aScreenId, aAddress, aWidth, aHeight, 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
    {


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOT_ENTER(this, aScreenId, aAddress, aWidth, aHeight, aBitmapFormat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = takeScreenShot(aScreenId,
                                 aAddress,
                                 aWidth,
                                 aHeight,
                                 aBitmapFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOT_RETURN(this, hrc, 0 /*normal*/, aScreenId, aAddress, aWidth, aHeight, aBitmapFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOT_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aAddress, aWidth, aHeight, aBitmapFormat);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOT_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aAddress, aWidth, aHeight, aBitmapFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::takeScreenShot", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::TakeScreenShotToArray(ULONG aScreenId,
                                                ULONG aWidth,
                                                ULONG aHeight,
                                                BitmapFormat_T aBitmapFormat,
                                                ComSafeArrayOut(BYTE, aScreenData))
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aWidth=%RU32 aHeight=%RU32 aBitmapFormat=%RU32 aScreenData=%p\n", this, "Display::takeScreenShotToArray", aScreenId, aWidth, aHeight, aBitmapFormat, aScreenData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenData);


        
        
        
        
        ArrayOutConverter<BYTE> TmpScreenData(ComSafeArrayOutArg(aScreenData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOTTOARRAY_ENTER(this, aScreenId, aWidth, aHeight, aBitmapFormat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = takeScreenShotToArray(aScreenId,
                                        aWidth,
                                        aHeight,
                                        aBitmapFormat,
                                        TmpScreenData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOTTOARRAY_RETURN(this, hrc, 0 /*normal*/, aScreenId, aWidth, aHeight, aBitmapFormat, (uint32_t)TmpScreenData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOTTOARRAY_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aWidth, aHeight, aBitmapFormat, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_TAKESCREENSHOTTOARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aWidth, aHeight, aBitmapFormat, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aScreenData=%zu hrc=%Rhrc\n", this, "Display::takeScreenShotToArray", !RT_VALID_PTR(aScreenData) ? 0 : ComSafeArraySize(*aScreenData), hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::DrawToScreen(ULONG aScreenId,
                                       BYTE *aAddress,
                                       ULONG aX,
                                       ULONG aY,
                                       ULONG aWidth,
                                       ULONG aHeight)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aAddress=%p aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Display::drawToScreen", aScreenId, aAddress, 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_DISPLAY_DRAWTOSCREEN_ENTER(this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = drawToScreen(aScreenId,
                               aAddress,
                               aX,
                               aY,
                               aWidth,
                               aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DRAWTOSCREEN_RETURN(this, hrc, 0 /*normal*/, aScreenId, aAddress, aX, aY, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DRAWTOSCREEN_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aAddress, aX, aY, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DRAWTOSCREEN_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aAddress, aX, aY, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::drawToScreen", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::InvalidateAndUpdate()
{
    LogRelFlow(("{%p} %s: enter\n", this, "Display::invalidateAndUpdate"));

    // Clear 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_DISPLAY_INVALIDATEANDUPDATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = invalidateAndUpdate();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::invalidateAndUpdate", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::InvalidateAndUpdateScreen(ULONG aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32\n", this, "Display::invalidateAndUpdateScreen", 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_DISPLAY_INVALIDATEANDUPDATESCREEN_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = invalidateAndUpdateScreen(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATESCREEN_RETURN(this, hrc, 0 /*normal*/, aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATESCREEN_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_INVALIDATEANDUPDATESCREEN_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::invalidateAndUpdateScreen", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::ViewportChanged(ULONG aScreenId,
                                          ULONG aX,
                                          ULONG aY,
                                          ULONG aWidth,
                                          ULONG aHeight)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Display::viewportChanged", aScreenId, 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_DISPLAY_VIEWPORTCHANGED_ENTER(this, aScreenId, aX, aY, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = viewportChanged(aScreenId,
                                  aX,
                                  aY,
                                  aWidth,
                                  aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_VIEWPORTCHANGED_RETURN(this, hrc, 0 /*normal*/, aScreenId, aX, aY, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_VIEWPORTCHANGED_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aX, aY, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_VIEWPORTCHANGED_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aX, aY, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::viewportChanged", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::QuerySourceBitmap(ULONG aScreenId,
                                            IDisplaySourceBitmap **aDisplaySourceBitmap)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aDisplaySourceBitmap=%p\n", this, "Display::querySourceBitmap", aScreenId, aDisplaySourceBitmap));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDisplaySourceBitmap);


        
        ComTypeOutConverter<IDisplaySourceBitmap> TmpDisplaySourceBitmap(aDisplaySourceBitmap);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYSOURCEBITMAP_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySourceBitmap(aScreenId,
                                    TmpDisplaySourceBitmap.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYSOURCEBITMAP_RETURN(this, hrc, 0 /*normal*/, aScreenId, (void *)TmpDisplaySourceBitmap.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYSOURCEBITMAP_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_QUERYSOURCEBITMAP_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDisplaySourceBitmap=%p hrc=%Rhrc\n", this, "Display::querySourceBitmap", !RT_VALID_PTR(aDisplaySourceBitmap) ? 0 : *aDisplaySourceBitmap, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::NotifyScaleFactorChange(ULONG aScreenId,
                                                  ULONG aU32ScaleFactorWMultiplied,
                                                  ULONG aU32ScaleFactorHMultiplied)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%RU32 aU32ScaleFactorWMultiplied=%RU32 aU32ScaleFactorHMultiplied=%RU32\n", this, "Display::notifyScaleFactorChange", aScreenId, aU32ScaleFactorWMultiplied, aU32ScaleFactorHMultiplied));

    // Clear 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_DISPLAY_NOTIFYSCALEFACTORCHANGE_ENTER(this, aScreenId, aU32ScaleFactorWMultiplied, aU32ScaleFactorHMultiplied);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyScaleFactorChange(aScreenId,
                                          aU32ScaleFactorWMultiplied,
                                          aU32ScaleFactorHMultiplied);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYSCALEFACTORCHANGE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aU32ScaleFactorWMultiplied, aU32ScaleFactorHMultiplied);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYSCALEFACTORCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aU32ScaleFactorWMultiplied, aU32ScaleFactorHMultiplied);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYSCALEFACTORCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aU32ScaleFactorWMultiplied, aU32ScaleFactorHMultiplied);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::notifyScaleFactorChange", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::NotifyHiDPIOutputPolicyChange(BOOL aFUnscaledHiDPI)
{
    LogRelFlow(("{%p} %s: enter aFUnscaledHiDPI=%RTbool\n", this, "Display::notifyHiDPIOutputPolicyChange", aFUnscaledHiDPI));

    // Clear 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_DISPLAY_NOTIFYHIDPIOUTPUTPOLICYCHANGE_ENTER(this, aFUnscaledHiDPI != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyHiDPIOutputPolicyChange(aFUnscaledHiDPI != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYHIDPIOUTPUTPOLICYCHANGE_RETURN(this, hrc, 0 /*normal*/, aFUnscaledHiDPI != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYHIDPIOUTPUTPOLICYCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aFUnscaledHiDPI != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_NOTIFYHIDPIOUTPUTPOLICYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aFUnscaledHiDPI != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::notifyHiDPIOutputPolicyChange", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::SetScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
                                          ComSafeArrayIn(IGuestScreenInfo *, aGuestScreenInfo))
{
    LogRelFlow(("{%p} %s: enter aScreenLayoutMode=%RU32 aGuestScreenInfo=%zu\n", this, "Display::setScreenLayout", aScreenLayoutMode, aGuestScreenInfo));

    // Clear 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<IGuestScreenInfo> TmpGuestScreenInfo(ComSafeArrayInArg(aGuestScreenInfo));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSCREENLAYOUT_ENTER(this, aScreenLayoutMode, (uint32_t)TmpGuestScreenInfo.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setScreenLayout(aScreenLayoutMode,
                                  TmpGuestScreenInfo.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSCREENLAYOUT_RETURN(this, hrc, 0 /*normal*/, aScreenLayoutMode, (uint32_t)TmpGuestScreenInfo.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSCREENLAYOUT_RETURN(this, hrc, 1 /*hrc exception*/, aScreenLayoutMode, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_SETSCREENLAYOUT_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenLayoutMode, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::setScreenLayout", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::DetachScreens(ComSafeArrayIn(LONG, aScreenIds))
{
    LogRelFlow(("{%p} %s: enter aScreenIds=%zu\n", this, "Display::detachScreens", aScreenIds));

    // Clear 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<LONG> TmpScreenIds(ComSafeArrayInArg(aScreenIds));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHSCREENS_ENTER(this, (uint32_t)TmpScreenIds.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = detachScreens(TmpScreenIds.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHSCREENS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpScreenIds.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHSCREENS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_DETACHSCREENS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::detachScreens", hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::CreateGuestScreenInfo(ULONG aDisplay,
                                                GuestMonitorStatus_T aStatus,
                                                BOOL aPrimary,
                                                BOOL aChangeOrigin,
                                                LONG aOriginX,
                                                LONG aOriginY,
                                                ULONG aWidth,
                                                ULONG aHeight,
                                                ULONG aBitsPerPixel,
                                                IGuestScreenInfo **aGuestScreenInfo)
{
    LogRelFlow(("{%p} %s: enter aDisplay=%RU32 aStatus=%RU32 aPrimary=%RTbool aChangeOrigin=%RTbool aOriginX=%RI32 aOriginY=%RI32 aWidth=%RU32 aHeight=%RU32 aBitsPerPixel=%RU32 aGuestScreenInfo=%p\n", this, "Display::createGuestScreenInfo", aDisplay, aStatus, aPrimary, aChangeOrigin, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, aGuestScreenInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestScreenInfo);


        
        
        
        
        
        
        
        
        
        ComTypeOutConverter<IGuestScreenInfo> TmpGuestScreenInfo(aGuestScreenInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_CREATEGUESTSCREENINFO_ENTER(this, aDisplay, aStatus, aPrimary != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createGuestScreenInfo(aDisplay,
                                        aStatus,
                                        aPrimary != FALSE,
                                        aChangeOrigin != FALSE,
                                        aOriginX,
                                        aOriginY,
                                        aWidth,
                                        aHeight,
                                        aBitsPerPixel,
                                        TmpGuestScreenInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_CREATEGUESTSCREENINFO_RETURN(this, hrc, 0 /*normal*/, aDisplay, aStatus, aPrimary != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, (void *)TmpGuestScreenInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_CREATEGUESTSCREENINFO_RETURN(this, hrc, 1 /*hrc exception*/, aDisplay, aStatus, aPrimary != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_CREATEGUESTSCREENINFO_RETURN(this, hrc, 9 /*unhandled exception*/, aDisplay, aStatus, aPrimary != FALSE, aChangeOrigin != FALSE, aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestScreenInfo=%p hrc=%Rhrc\n", this, "Display::createGuestScreenInfo", !RT_VALID_PTR(aGuestScreenInfo) ? 0 : *aGuestScreenInfo, hrc));
    return hrc;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod1IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod2IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod3IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod4IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod5IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod6IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod7IDisplay()
{
    return E_NOTIMPL;
}

STDMETHODIMP DisplayWrap::InternalAndReservedMethod8IDisplay()
{
    return E_NOTIMPL;
}

//
// IEventListener methods
//

STDMETHODIMP DisplayWrap::HandleEvent(IEvent *aEvent)
{
    LogRelFlow(("{%p} %s: enter aEvent=%p\n", this, "Display::handleEvent", 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<IEvent> TmpEvent(aEvent);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_HANDLEEVENT_ENTER(this, (void *)TmpEvent.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = handleEvent(TmpEvent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_HANDLEEVENT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpEvent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_HANDLEEVENT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAY_HANDLEEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Display::handleEvent", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DisplayWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DisplayWrap, IDisplay, IEventListener)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DisplayWrap.cpp"


// ##### BEGINFILE "NetworkAdapterWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for INetworkAdapter.
 *
 * 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_NETWORKADAPTER

#include "NetworkAdapterWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(NetworkAdapterWrap)

//
// INetworkAdapter properties
//

STDMETHODIMP NetworkAdapterWrap::COMGETTER(AdapterType)(NetworkAdapterType_T *aAdapterType)
{
    LogRelFlow(("{%p} %s: enter aAdapterType=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_GET_ADAPTERTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdapterType(aAdapterType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ADAPTERTYPE_RETURN(this, hrc, 0 /*normal*/,*aAdapterType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_GET_ADAPTERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAdapterType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdapterType=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getAdapterType", !RT_VALID_PTR(aAdapterType) ? 0 : *aAdapterType, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(AdapterType)(NetworkAdapterType_T aAdapterType)
{
    LogRelFlow(("{%p} %s: enter aAdapterType=%RU32\n", this, "NetworkAdapter::setAdapterType", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ADAPTERTYPE_ENTER(this, aAdapterType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAdapterType(aAdapterType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ADAPTERTYPE_RETURN(this, hrc, 0 /*normal*/,aAdapterType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ADAPTERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aAdapterType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ADAPTERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aAdapterType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setAdapterType", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(Slot)(ULONG *aSlot)
{
    LogRelFlow(("{%p} %s: enter aSlot=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_GET_SLOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSlot(aSlot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_SLOT_RETURN(this, hrc, 0 /*normal*/,*aSlot);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_GET_SLOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSlot);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSlot=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getSlot", !RT_VALID_PTR(aSlot) ? 0 : *aSlot, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "NetworkAdapter::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "NetworkAdapter::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_NETWORKADAPTER_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_NETWORKADAPTER_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(MACAddress)(BSTR *aMACAddress)
{
    LogRelFlow(("{%p} %s: enter aMACAddress=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_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_NETWORKADAPTER_GET_MACADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpMACAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_GET_MACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMACAddress=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getMACAddress", !RT_VALID_PTR(aMACAddress) ? 0 : *aMACAddress, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(MACAddress)(IN_BSTR aMACAddress)
{
    LogRelFlow(("{%p} %s: enter aMACAddress=%ls\n", this, "NetworkAdapter::setMACAddress", 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
    {
        BSTRInConverter TmpMACAddress(aMACAddress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_MACADDRESS_ENTER(this, TmpMACAddress.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMACAddress(TmpMACAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_MACADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpMACAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_MACADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_MACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setMACAddress", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(AttachmentType)(NetworkAttachmentType_T *aAttachmentType)
{
    LogRelFlow(("{%p} %s: enter aAttachmentType=%p\n", this, "NetworkAdapter::getAttachmentType", aAttachmentType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAttachmentType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ATTACHMENTTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAttachmentType(aAttachmentType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ATTACHMENTTYPE_RETURN(this, hrc, 0 /*normal*/,*aAttachmentType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ATTACHMENTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAttachmentType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_ATTACHMENTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAttachmentType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAttachmentType=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getAttachmentType", !RT_VALID_PTR(aAttachmentType) ? 0 : *aAttachmentType, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(AttachmentType)(NetworkAttachmentType_T aAttachmentType)
{
    LogRelFlow(("{%p} %s: enter aAttachmentType=%RU32\n", this, "NetworkAdapter::setAttachmentType", aAttachmentType));

    // Clear 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_NETWORKADAPTER_SET_ATTACHMENTTYPE_ENTER(this, aAttachmentType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAttachmentType(aAttachmentType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ATTACHMENTTYPE_RETURN(this, hrc, 0 /*normal*/,aAttachmentType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ATTACHMENTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aAttachmentType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_ATTACHMENTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aAttachmentType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setAttachmentType", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(BridgedInterface)(BSTR *aBridgedInterface)
{
    LogRelFlow(("{%p} %s: enter aBridgedInterface=%p\n", this, "NetworkAdapter::getBridgedInterface", aBridgedInterface));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBridgedInterface);
        BSTROutConverter TmpBridgedInterface(aBridgedInterface);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BRIDGEDINTERFACE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBridgedInterface(TmpBridgedInterface.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BRIDGEDINTERFACE_RETURN(this, hrc, 0 /*normal*/,TmpBridgedInterface.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BRIDGEDINTERFACE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BRIDGEDINTERFACE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBridgedInterface=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getBridgedInterface", !RT_VALID_PTR(aBridgedInterface) ? 0 : *aBridgedInterface, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(BridgedInterface)(IN_BSTR aBridgedInterface)
{
    LogRelFlow(("{%p} %s: enter aBridgedInterface=%ls\n", this, "NetworkAdapter::setBridgedInterface", aBridgedInterface));

    // Clear 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 TmpBridgedInterface(aBridgedInterface);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BRIDGEDINTERFACE_ENTER(this, TmpBridgedInterface.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBridgedInterface(TmpBridgedInterface.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BRIDGEDINTERFACE_RETURN(this, hrc, 0 /*normal*/,TmpBridgedInterface.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BRIDGEDINTERFACE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BRIDGEDINTERFACE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setBridgedInterface", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(HostOnlyInterface)(BSTR *aHostOnlyInterface)
{
    LogRelFlow(("{%p} %s: enter aHostOnlyInterface=%p\n", this, "NetworkAdapter::getHostOnlyInterface", aHostOnlyInterface));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostOnlyInterface);
        BSTROutConverter TmpHostOnlyInterface(aHostOnlyInterface);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYINTERFACE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostOnlyInterface(TmpHostOnlyInterface.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYINTERFACE_RETURN(this, hrc, 0 /*normal*/,TmpHostOnlyInterface.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYINTERFACE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYINTERFACE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostOnlyInterface=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getHostOnlyInterface", !RT_VALID_PTR(aHostOnlyInterface) ? 0 : *aHostOnlyInterface, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(HostOnlyInterface)(IN_BSTR aHostOnlyInterface)
{
    LogRelFlow(("{%p} %s: enter aHostOnlyInterface=%ls\n", this, "NetworkAdapter::setHostOnlyInterface", aHostOnlyInterface));

    // Clear 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 TmpHostOnlyInterface(aHostOnlyInterface);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYINTERFACE_ENTER(this, TmpHostOnlyInterface.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostOnlyInterface(TmpHostOnlyInterface.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYINTERFACE_RETURN(this, hrc, 0 /*normal*/,TmpHostOnlyInterface.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYINTERFACE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYINTERFACE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setHostOnlyInterface", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(HostOnlyNetwork)(BSTR *aHostOnlyNetwork)
{
    LogRelFlow(("{%p} %s: enter aHostOnlyNetwork=%p\n", this, "NetworkAdapter::getHostOnlyNetwork", aHostOnlyNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostOnlyNetwork);
        BSTROutConverter TmpHostOnlyNetwork(aHostOnlyNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYNETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostOnlyNetwork(TmpHostOnlyNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpHostOnlyNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_HOSTONLYNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostOnlyNetwork=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getHostOnlyNetwork", !RT_VALID_PTR(aHostOnlyNetwork) ? 0 : *aHostOnlyNetwork, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(HostOnlyNetwork)(IN_BSTR aHostOnlyNetwork)
{
    LogRelFlow(("{%p} %s: enter aHostOnlyNetwork=%ls\n", this, "NetworkAdapter::setHostOnlyNetwork", aHostOnlyNetwork));

    // Clear 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 TmpHostOnlyNetwork(aHostOnlyNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYNETWORK_ENTER(this, TmpHostOnlyNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostOnlyNetwork(TmpHostOnlyNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpHostOnlyNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_HOSTONLYNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setHostOnlyNetwork", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalNetwork)(BSTR *aInternalNetwork)
{
    LogRelFlow(("{%p} %s: enter aInternalNetwork=%p\n", this, "NetworkAdapter::getInternalNetwork", aInternalNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInternalNetwork);
        BSTROutConverter TmpInternalNetwork(aInternalNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_INTERNALNETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInternalNetwork(TmpInternalNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_INTERNALNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpInternalNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_INTERNALNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_INTERNALNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInternalNetwork=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getInternalNetwork", !RT_VALID_PTR(aInternalNetwork) ? 0 : *aInternalNetwork, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(InternalNetwork)(IN_BSTR aInternalNetwork)
{
    LogRelFlow(("{%p} %s: enter aInternalNetwork=%ls\n", this, "NetworkAdapter::setInternalNetwork", aInternalNetwork));

    // Clear 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 TmpInternalNetwork(aInternalNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_INTERNALNETWORK_ENTER(this, TmpInternalNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInternalNetwork(TmpInternalNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_INTERNALNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpInternalNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_INTERNALNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_INTERNALNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setInternalNetwork", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(NATNetwork)(BSTR *aNATNetwork)
{
    LogRelFlow(("{%p} %s: enter aNATNetwork=%p\n", this, "NetworkAdapter::getNATNetwork", aNATNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNATNetwork);
        BSTROutConverter TmpNATNetwork(aNATNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATNETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNATNetwork(TmpNATNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNATNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNATNetwork=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getNATNetwork", !RT_VALID_PTR(aNATNetwork) ? 0 : *aNATNetwork, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(NATNetwork)(IN_BSTR aNATNetwork)
{
    LogRelFlow(("{%p} %s: enter aNATNetwork=%ls\n", this, "NetworkAdapter::setNATNetwork", aNATNetwork));

    // Clear 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 TmpNATNetwork(aNATNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_NATNETWORK_ENTER(this, TmpNATNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNATNetwork(TmpNATNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_NATNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNATNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_NATNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_NATNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setNATNetwork", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(GenericDriver)(BSTR *aGenericDriver)
{
    LogRelFlow(("{%p} %s: enter aGenericDriver=%p\n", this, "NetworkAdapter::getGenericDriver", aGenericDriver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGenericDriver);
        BSTROutConverter TmpGenericDriver(aGenericDriver);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_GENERICDRIVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGenericDriver(TmpGenericDriver.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_GENERICDRIVER_RETURN(this, hrc, 0 /*normal*/,TmpGenericDriver.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_GENERICDRIVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_GENERICDRIVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGenericDriver=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getGenericDriver", !RT_VALID_PTR(aGenericDriver) ? 0 : *aGenericDriver, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(GenericDriver)(IN_BSTR aGenericDriver)
{
    LogRelFlow(("{%p} %s: enter aGenericDriver=%ls\n", this, "NetworkAdapter::setGenericDriver", aGenericDriver));

    // Clear 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 TmpGenericDriver(aGenericDriver);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_GENERICDRIVER_ENTER(this, TmpGenericDriver.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setGenericDriver(TmpGenericDriver.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_GENERICDRIVER_RETURN(this, hrc, 0 /*normal*/,TmpGenericDriver.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_GENERICDRIVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_GENERICDRIVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setGenericDriver", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(CloudNetwork)(BSTR *aCloudNetwork)
{
    LogRelFlow(("{%p} %s: enter aCloudNetwork=%p\n", this, "NetworkAdapter::getCloudNetwork", aCloudNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudNetwork);
        BSTROutConverter TmpCloudNetwork(aCloudNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CLOUDNETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudNetwork(TmpCloudNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CLOUDNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpCloudNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CLOUDNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CLOUDNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudNetwork=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getCloudNetwork", !RT_VALID_PTR(aCloudNetwork) ? 0 : *aCloudNetwork, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(CloudNetwork)(IN_BSTR aCloudNetwork)
{
    LogRelFlow(("{%p} %s: enter aCloudNetwork=%ls\n", this, "NetworkAdapter::setCloudNetwork", aCloudNetwork));

    // Clear 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 TmpCloudNetwork(aCloudNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CLOUDNETWORK_ENTER(this, TmpCloudNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCloudNetwork(TmpCloudNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CLOUDNETWORK_RETURN(this, hrc, 0 /*normal*/,TmpCloudNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CLOUDNETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CLOUDNETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setCloudNetwork", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(CableConnected)(BOOL *aCableConnected)
{
    LogRelFlow(("{%p} %s: enter aCableConnected=%p\n", this, "NetworkAdapter::getCableConnected", aCableConnected));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCableConnected);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CABLECONNECTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCableConnected(aCableConnected);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CABLECONNECTED_RETURN(this, hrc, 0 /*normal*/,*aCableConnected != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CABLECONNECTED_RETURN(this, hrc, 1 /*hrc exception*/,*aCableConnected != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_CABLECONNECTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCableConnected != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCableConnected=%RTbool hrc=%Rhrc\n", this, "NetworkAdapter::getCableConnected", !RT_VALID_PTR(aCableConnected) ? 0 : *aCableConnected, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(CableConnected)(BOOL aCableConnected)
{
    LogRelFlow(("{%p} %s: enter aCableConnected=%RTbool\n", this, "NetworkAdapter::setCableConnected", aCableConnected));

    // Clear 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_NETWORKADAPTER_SET_CABLECONNECTED_ENTER(this, aCableConnected != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCableConnected(aCableConnected != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CABLECONNECTED_RETURN(this, hrc, 0 /*normal*/,aCableConnected != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CABLECONNECTED_RETURN(this, hrc, 1 /*hrc exception*/,aCableConnected != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_CABLECONNECTED_RETURN(this, hrc, 9 /*unhandled exception*/,aCableConnected != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setCableConnected", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(LineSpeed)(ULONG *aLineSpeed)
{
    LogRelFlow(("{%p} %s: enter aLineSpeed=%p\n", this, "NetworkAdapter::getLineSpeed", aLineSpeed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLineSpeed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_LINESPEED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLineSpeed(aLineSpeed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_LINESPEED_RETURN(this, hrc, 0 /*normal*/,*aLineSpeed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_LINESPEED_RETURN(this, hrc, 1 /*hrc exception*/,*aLineSpeed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_LINESPEED_RETURN(this, hrc, 9 /*unhandled exception*/,*aLineSpeed);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLineSpeed=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getLineSpeed", !RT_VALID_PTR(aLineSpeed) ? 0 : *aLineSpeed, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(LineSpeed)(ULONG aLineSpeed)
{
    LogRelFlow(("{%p} %s: enter aLineSpeed=%RU32\n", this, "NetworkAdapter::setLineSpeed", aLineSpeed));

    // Clear 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_NETWORKADAPTER_SET_LINESPEED_ENTER(this, aLineSpeed);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLineSpeed(aLineSpeed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_LINESPEED_RETURN(this, hrc, 0 /*normal*/,aLineSpeed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_LINESPEED_RETURN(this, hrc, 1 /*hrc exception*/,aLineSpeed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_LINESPEED_RETURN(this, hrc, 9 /*unhandled exception*/,aLineSpeed);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setLineSpeed", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(PromiscModePolicy)(NetworkAdapterPromiscModePolicy_T *aPromiscModePolicy)
{
    LogRelFlow(("{%p} %s: enter aPromiscModePolicy=%p\n", this, "NetworkAdapter::getPromiscModePolicy", aPromiscModePolicy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPromiscModePolicy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_PROMISCMODEPOLICY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPromiscModePolicy(aPromiscModePolicy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_PROMISCMODEPOLICY_RETURN(this, hrc, 0 /*normal*/,*aPromiscModePolicy);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_PROMISCMODEPOLICY_RETURN(this, hrc, 1 /*hrc exception*/,*aPromiscModePolicy);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_PROMISCMODEPOLICY_RETURN(this, hrc, 9 /*unhandled exception*/,*aPromiscModePolicy);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPromiscModePolicy=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getPromiscModePolicy", !RT_VALID_PTR(aPromiscModePolicy) ? 0 : *aPromiscModePolicy, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(PromiscModePolicy)(NetworkAdapterPromiscModePolicy_T aPromiscModePolicy)
{
    LogRelFlow(("{%p} %s: enter aPromiscModePolicy=%RU32\n", this, "NetworkAdapter::setPromiscModePolicy", aPromiscModePolicy));

    // Clear 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_NETWORKADAPTER_SET_PROMISCMODEPOLICY_ENTER(this, aPromiscModePolicy);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPromiscModePolicy(aPromiscModePolicy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_PROMISCMODEPOLICY_RETURN(this, hrc, 0 /*normal*/,aPromiscModePolicy);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_PROMISCMODEPOLICY_RETURN(this, hrc, 1 /*hrc exception*/,aPromiscModePolicy);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_PROMISCMODEPOLICY_RETURN(this, hrc, 9 /*unhandled exception*/,aPromiscModePolicy);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setPromiscModePolicy", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(TraceEnabled)(BOOL *aTraceEnabled)
{
    LogRelFlow(("{%p} %s: enter aTraceEnabled=%p\n", this, "NetworkAdapter::getTraceEnabled", aTraceEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTraceEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTraceEnabled(aTraceEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEENABLED_RETURN(this, hrc, 0 /*normal*/,*aTraceEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aTraceEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aTraceEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTraceEnabled=%RTbool hrc=%Rhrc\n", this, "NetworkAdapter::getTraceEnabled", !RT_VALID_PTR(aTraceEnabled) ? 0 : *aTraceEnabled, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(TraceEnabled)(BOOL aTraceEnabled)
{
    LogRelFlow(("{%p} %s: enter aTraceEnabled=%RTbool\n", this, "NetworkAdapter::setTraceEnabled", aTraceEnabled));

    // Clear 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_NETWORKADAPTER_SET_TRACEENABLED_ENTER(this, aTraceEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTraceEnabled(aTraceEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEENABLED_RETURN(this, hrc, 0 /*normal*/,aTraceEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aTraceEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aTraceEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setTraceEnabled", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(TraceFile)(BSTR *aTraceFile)
{
    LogRelFlow(("{%p} %s: enter aTraceFile=%p\n", this, "NetworkAdapter::getTraceFile", aTraceFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTraceFile);
        BSTROutConverter TmpTraceFile(aTraceFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTraceFile(TmpTraceFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEFILE_RETURN(this, hrc, 0 /*normal*/,TmpTraceFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_TRACEFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTraceFile=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getTraceFile", !RT_VALID_PTR(aTraceFile) ? 0 : *aTraceFile, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(TraceFile)(IN_BSTR aTraceFile)
{
    LogRelFlow(("{%p} %s: enter aTraceFile=%ls\n", this, "NetworkAdapter::setTraceFile", aTraceFile));

    // Clear 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 TmpTraceFile(aTraceFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEFILE_ENTER(this, TmpTraceFile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTraceFile(TmpTraceFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEFILE_RETURN(this, hrc, 0 /*normal*/,TmpTraceFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_TRACEFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setTraceFile", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(NATEngine)(INATEngine **aNATEngine)
{
    LogRelFlow(("{%p} %s: enter aNATEngine=%p\n", this, "NetworkAdapter::getNATEngine", aNATEngine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNATEngine);
        ComTypeOutConverter<INATEngine> TmpNATEngine(aNATEngine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATENGINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNATEngine(TmpNATEngine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATENGINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpNATEngine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATENGINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_NATENGINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNATEngine=%p hrc=%Rhrc\n", this, "NetworkAdapter::getNATEngine", !RT_VALID_PTR(aNATEngine) ? 0 : *aNATEngine, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(BootPriority)(ULONG *aBootPriority)
{
    LogRelFlow(("{%p} %s: enter aBootPriority=%p\n", this, "NetworkAdapter::getBootPriority", aBootPriority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBootPriority);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BOOTPRIORITY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootPriority(aBootPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BOOTPRIORITY_RETURN(this, hrc, 0 /*normal*/,*aBootPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BOOTPRIORITY_RETURN(this, hrc, 1 /*hrc exception*/,*aBootPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GET_BOOTPRIORITY_RETURN(this, hrc, 9 /*unhandled exception*/,*aBootPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBootPriority=%RU32 hrc=%Rhrc\n", this, "NetworkAdapter::getBootPriority", !RT_VALID_PTR(aBootPriority) ? 0 : *aBootPriority, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(BootPriority)(ULONG aBootPriority)
{
    LogRelFlow(("{%p} %s: enter aBootPriority=%RU32\n", this, "NetworkAdapter::setBootPriority", aBootPriority));

    // Clear 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_NETWORKADAPTER_SET_BOOTPRIORITY_ENTER(this, aBootPriority);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBootPriority(aBootPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BOOTPRIORITY_RETURN(this, hrc, 0 /*normal*/,aBootPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BOOTPRIORITY_RETURN(this, hrc, 1 /*hrc exception*/,aBootPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BOOTPRIORITY_RETURN(this, hrc, 9 /*unhandled exception*/,aBootPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setBootPriority", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(BandwidthGroup)(IBandwidthGroup **aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroup=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_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_NETWORKADAPTER_GET_BANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_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_NETWORKADAPTER_GET_BANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBandwidthGroup=%p hrc=%Rhrc\n", this, "NetworkAdapter::getBandwidthGroup", !RT_VALID_PTR(aBandwidthGroup) ? 0 : *aBandwidthGroup, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMSETTER(BandwidthGroup)(IBandwidthGroup *aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroup=%p\n", this, "NetworkAdapter::setBandwidthGroup", 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_NETWORKADAPTER_SET_BANDWIDTHGROUP_ENTER(this, (void *)TmpBandwidthGroup.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setBandwidthGroup(TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SET_BANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setBandwidthGroup", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute1INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute2INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute3INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute4INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute5INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute6INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute7INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::COMGETTER(InternalAndReservedAttribute8INetworkAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// INetworkAdapter methods
//

STDMETHODIMP NetworkAdapterWrap::GetProperty(IN_BSTR aKey,
                                             BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "NetworkAdapter::getProperty", 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_NETWORKADAPTER_GETPROPERTY_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperty(TmpKey.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_GETPROPERTY_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_NETWORKADAPTER_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_NETWORKADAPTER_GETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "NetworkAdapter::getProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::SetProperty(IN_BSTR aKey,
                                             IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%ls\n", this, "NetworkAdapter::setProperty", 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_NETWORKADAPTER_SETPROPERTY_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProperty(TmpKey.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NETWORKADAPTER_SETPROPERTY_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_NETWORKADAPTER_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_NETWORKADAPTER_SETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NetworkAdapter::setProperty", hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::GetProperties(IN_BSTR aNames,
                                               ComSafeArrayOut(BSTR, aReturnNames),
                                               ComSafeArrayOut(BSTR, aReturnValues))
{
    LogRelFlow(("{%p} %s: enter aNames=%ls aReturnNames=%p aReturnValues=%p\n", this, "NetworkAdapter::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_NETWORKADAPTER_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_NETWORKADAPTER_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_NETWORKADAPTER_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_NETWORKADAPTER_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, "NetworkAdapter::getProperties", !RT_VALID_PTR(aReturnNames) ? 0 : ComSafeArraySize(*aReturnNames), !RT_VALID_PTR(aReturnValues) ? 0 : ComSafeArraySize(*aReturnValues), hrc));
    return hrc;
}

STDMETHODIMP NetworkAdapterWrap::InternalAndReservedMethod1INetworkAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::InternalAndReservedMethod2INetworkAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::InternalAndReservedMethod3INetworkAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP NetworkAdapterWrap::InternalAndReservedMethod4INetworkAdapter()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(NetworkAdapterWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NetworkAdapterWrap, INetworkAdapter)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "NetworkAdapterWrap.cpp"


// ##### BEGINFILE "ParallelPortWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IParallelPort.
 *
 * 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_PARALLELPORT

#include "ParallelPortWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ParallelPortWrap)

//
// IParallelPort properties
//

STDMETHODIMP ParallelPortWrap::COMGETTER(Slot)(ULONG *aSlot)
{
    LogRelFlow(("{%p} %s: enter aSlot=%p\n", this, "ParallelPort::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_PARALLELPORT_GET_SLOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSlot(aSlot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_SLOT_RETURN(this, hrc, 0 /*normal*/,*aSlot);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_GET_SLOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSlot);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSlot=%RU32 hrc=%Rhrc\n", this, "ParallelPort::getSlot", !RT_VALID_PTR(aSlot) ? 0 : *aSlot, hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "ParallelPort::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_PARALLELPORT_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "ParallelPort::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "ParallelPort::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_PARALLELPORT_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_PARALLELPORT_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ParallelPort::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(IOBase)(ULONG *aIOBase)
{
    LogRelFlow(("{%p} %s: enter aIOBase=%p\n", this, "ParallelPort::getIOBase", aIOBase));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIOBase);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_IOBASE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOBase(aIOBase);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_IOBASE_RETURN(this, hrc, 0 /*normal*/,*aIOBase);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_IOBASE_RETURN(this, hrc, 1 /*hrc exception*/,*aIOBase);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_IOBASE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOBase);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOBase=%RU32 hrc=%Rhrc\n", this, "ParallelPort::getIOBase", !RT_VALID_PTR(aIOBase) ? 0 : *aIOBase, hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMSETTER(IOBase)(ULONG aIOBase)
{
    LogRelFlow(("{%p} %s: enter aIOBase=%RU32\n", this, "ParallelPort::setIOBase", aIOBase));

    // Clear 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_PARALLELPORT_SET_IOBASE_ENTER(this, aIOBase);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOBase(aIOBase);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_SET_IOBASE_RETURN(this, hrc, 0 /*normal*/,aIOBase);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_SET_IOBASE_RETURN(this, hrc, 1 /*hrc exception*/,aIOBase);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_SET_IOBASE_RETURN(this, hrc, 9 /*unhandled exception*/,aIOBase);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ParallelPort::setIOBase", hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(IRQ)(ULONG *aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%p\n", this, "ParallelPort::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_PARALLELPORT_GET_IRQ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIRQ(aIRQ);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_GET_IRQ_RETURN(this, hrc, 0 /*normal*/,*aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_GET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,*aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIRQ=%RU32 hrc=%Rhrc\n", this, "ParallelPort::getIRQ", !RT_VALID_PTR(aIRQ) ? 0 : *aIRQ, hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMSETTER(IRQ)(ULONG aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%RU32\n", this, "ParallelPort::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_PARALLELPORT_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_PARALLELPORT_SET_IRQ_RETURN(this, hrc, 0 /*normal*/,aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_SET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ParallelPort::setIRQ", hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "ParallelPort::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_PARALLELPORT_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_PARALLELPORT_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPath=%ls hrc=%Rhrc\n", this, "ParallelPort::getPath", !RT_VALID_PTR(aPath) ? 0 : *aPath, hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMSETTER(Path)(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "ParallelPort::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_PARALLELPORT_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_PARALLELPORT_SET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PARALLELPORT_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_PARALLELPORT_SET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ParallelPort::setPath", hrc));
    return hrc;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(InternalAndReservedAttribute1IParallelPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(InternalAndReservedAttribute2IParallelPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(InternalAndReservedAttribute3IParallelPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ParallelPortWrap::COMGETTER(InternalAndReservedAttribute4IParallelPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IParallelPort methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ParallelPortWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ParallelPortWrap, IParallelPort)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ParallelPortWrap.cpp"


// ##### BEGINFILE "USBDeviceFiltersWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUSBDeviceFilters.
 *
 * 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_USBDEVICEFILTERS

#include "USBDeviceFiltersWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(USBDeviceFiltersWrap)

//
// IUSBDeviceFilters properties
//

STDMETHODIMP USBDeviceFiltersWrap::COMGETTER(DeviceFilters)(ComSafeArrayOut(IUSBDeviceFilter *, aDeviceFilters))
{
    LogRelFlow(("{%p} %s: enter aDeviceFilters=%p\n", this, "USBDeviceFilters::getDeviceFilters", aDeviceFilters));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceFilters);
        ArrayComTypeOutConverter<IUSBDeviceFilter> TmpDeviceFilters(ComSafeArrayOutArg(aDeviceFilters));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_GET_DEVICEFILTERS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceFilters(TmpDeviceFilters.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_GET_DEVICEFILTERS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDeviceFilters.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_GET_DEVICEFILTERS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_GET_DEVICEFILTERS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceFilters=%zu hrc=%Rhrc\n", this, "USBDeviceFilters::getDeviceFilters", !RT_VALID_PTR(aDeviceFilters) ? 0 : ComSafeArraySize(*aDeviceFilters), hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFiltersWrap::COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilters)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFiltersWrap::COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilters)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBDeviceFilters methods
//

STDMETHODIMP USBDeviceFiltersWrap::CreateDeviceFilter(IN_BSTR aName,
                                                      IUSBDeviceFilter **aFilter)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aFilter=%p\n", this, "USBDeviceFilters::createDeviceFilter", aName, 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);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IUSBDeviceFilter> TmpFilter(aFilter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_CREATEDEVICEFILTER_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createDeviceFilter(TmpName.str(),
                                     TmpFilter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_CREATEDEVICEFILTER_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpFilter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_CREATEDEVICEFILTER_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_CREATEDEVICEFILTER_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFilter=%p hrc=%Rhrc\n", this, "USBDeviceFilters::createDeviceFilter", !RT_VALID_PTR(aFilter) ? 0 : *aFilter, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFiltersWrap::InsertDeviceFilter(ULONG aPosition,
                                                      IUSBDeviceFilter *aFilter)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32 aFilter=%p\n", this, "USBDeviceFilters::insertDeviceFilter", aPosition, 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
    {


        
        ComTypeInConverter<IUSBDeviceFilter> TmpFilter(aFilter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_INSERTDEVICEFILTER_ENTER(this, aPosition, (void *)TmpFilter.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = insertDeviceFilter(aPosition,
                                     TmpFilter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_INSERTDEVICEFILTER_RETURN(this, hrc, 0 /*normal*/, aPosition, (void *)TmpFilter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_INSERTDEVICEFILTER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_INSERTDEVICEFILTER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBDeviceFilters::insertDeviceFilter", hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFiltersWrap::RemoveDeviceFilter(ULONG aPosition,
                                                      IUSBDeviceFilter **aFilter)
{
    LogRelFlow(("{%p} %s: enter aPosition=%RU32 aFilter=%p\n", this, "USBDeviceFilters::removeDeviceFilter", aPosition, 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);


        
        ComTypeOutConverter<IUSBDeviceFilter> TmpFilter(aFilter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_REMOVEDEVICEFILTER_ENTER(this, aPosition);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeDeviceFilter(aPosition,
                                     TmpFilter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_REMOVEDEVICEFILTER_RETURN(this, hrc, 0 /*normal*/, aPosition, (void *)TmpFilter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_REMOVEDEVICEFILTER_RETURN(this, hrc, 1 /*hrc exception*/, aPosition, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICEFILTERS_REMOVEDEVICEFILTER_RETURN(this, hrc, 9 /*unhandled exception*/, aPosition, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFilter=%p hrc=%Rhrc\n", this, "USBDeviceFilters::removeDeviceFilter", !RT_VALID_PTR(aFilter) ? 0 : *aFilter, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceFiltersWrap::InternalAndReservedMethod1IUSBDeviceFilters()
{
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceFiltersWrap::InternalAndReservedMethod2IUSBDeviceFilters()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(USBDeviceFiltersWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBDeviceFiltersWrap, IUSBDeviceFilters)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "USBDeviceFiltersWrap.cpp"


// ##### BEGINFILE "USBControllerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUSBController.
 *
 * 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_USBCONTROLLER

#include "USBControllerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(USBControllerWrap)

//
// IUSBController properties
//

STDMETHODIMP USBControllerWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "USBController::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_USBCONTROLLER_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_USBCONTROLLER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_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_USBCONTROLLER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "USBController::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP USBControllerWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "USBController::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_USBCONTROLLER_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_USBCONTROLLER_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_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_USBCONTROLLER_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBController::setName", hrc));
    return hrc;
}

STDMETHODIMP USBControllerWrap::COMGETTER(Type)(USBControllerType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "USBController::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_USBCONTROLLER_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_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_USBCONTROLLER_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "USBController::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP USBControllerWrap::COMSETTER(Type)(USBControllerType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "USBController::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_USBCONTROLLER_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_USBCONTROLLER_SET_TYPE_RETURN(this, hrc, 0 /*normal*/,aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_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_USBCONTROLLER_SET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "USBController::setType", hrc));
    return hrc;
}

STDMETHODIMP USBControllerWrap::COMGETTER(USBStandard)(USHORT *aUSBStandard)
{
    LogRelFlow(("{%p} %s: enter aUSBStandard=%p\n", this, "USBController::getUSBStandard", aUSBStandard));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUSBStandard);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_GET_USBSTANDARD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUSBStandard(aUSBStandard);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_GET_USBSTANDARD_RETURN(this, hrc, 0 /*normal*/,*aUSBStandard);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_GET_USBSTANDARD_RETURN(this, hrc, 1 /*hrc exception*/,*aUSBStandard);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBCONTROLLER_GET_USBSTANDARD_RETURN(this, hrc, 9 /*unhandled exception*/,*aUSBStandard);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUSBStandard=%RU16 hrc=%Rhrc\n", this, "USBController::getUSBStandard", !RT_VALID_PTR(aUSBStandard) ? 0 : *aUSBStandard, hrc));
    return hrc;
}

STDMETHODIMP USBControllerWrap::COMGETTER(InternalAndReservedAttribute1IUSBController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBControllerWrap::COMGETTER(InternalAndReservedAttribute2IUSBController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBControllerWrap::COMGETTER(InternalAndReservedAttribute3IUSBController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBControllerWrap::COMGETTER(InternalAndReservedAttribute4IUSBController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBController methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(USBControllerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBControllerWrap, IUSBController)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "USBControllerWrap.cpp"


// ##### BEGINFILE "USBDeviceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUSBDevice.
 *
 * 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_USBDEVICE

#include "USBDeviceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(USBDeviceWrap)

//
// IUSBDevice properties
//

STDMETHODIMP USBDeviceWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_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_USBDEVICE_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_USBDEVICE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "USBDevice::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(VendorId)(USHORT *aVendorId)
{
    LogRelFlow(("{%p} %s: enter aVendorId=%p\n", this, "USBDevice::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_USBDEVICE_GET_VENDORID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVendorId(aVendorId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_VENDORID_RETURN(this, hrc, 0 /*normal*/,*aVendorId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_VENDORID_RETURN(this, hrc, 9 /*unhandled exception*/,*aVendorId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVendorId=%RU16 hrc=%Rhrc\n", this, "USBDevice::getVendorId", !RT_VALID_PTR(aVendorId) ? 0 : *aVendorId, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(ProductId)(USHORT *aProductId)
{
    LogRelFlow(("{%p} %s: enter aProductId=%p\n", this, "USBDevice::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_USBDEVICE_GET_PRODUCTID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProductId(aProductId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_PRODUCTID_RETURN(this, hrc, 0 /*normal*/,*aProductId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_PRODUCTID_RETURN(this, hrc, 9 /*unhandled exception*/,*aProductId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProductId=%RU16 hrc=%Rhrc\n", this, "USBDevice::getProductId", !RT_VALID_PTR(aProductId) ? 0 : *aProductId, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Revision)(USHORT *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "USBDevice::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_USBDEVICE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU16 hrc=%Rhrc\n", this, "USBDevice::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Manufacturer)(BSTR *aManufacturer)
{
    LogRelFlow(("{%p} %s: enter aManufacturer=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_MANUFACTURER_RETURN(this, hrc, 0 /*normal*/,TmpManufacturer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_MANUFACTURER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aManufacturer=%ls hrc=%Rhrc\n", this, "USBDevice::getManufacturer", !RT_VALID_PTR(aManufacturer) ? 0 : *aManufacturer, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Product)(BSTR *aProduct)
{
    LogRelFlow(("{%p} %s: enter aProduct=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_PRODUCT_RETURN(this, hrc, 0 /*normal*/,TmpProduct.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_PRODUCT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProduct=%ls hrc=%Rhrc\n", this, "USBDevice::getProduct", !RT_VALID_PTR(aProduct) ? 0 : *aProduct, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(SerialNumber)(BSTR *aSerialNumber)
{
    LogRelFlow(("{%p} %s: enter aSerialNumber=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_SERIALNUMBER_RETURN(this, hrc, 0 /*normal*/,TmpSerialNumber.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_SERIALNUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSerialNumber=%ls hrc=%Rhrc\n", this, "USBDevice::getSerialNumber", !RT_VALID_PTR(aSerialNumber) ? 0 : *aSerialNumber, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Address)(BSTR *aAddress)
{
    LogRelFlow(("{%p} %s: enter aAddress=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_ADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_ADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAddress=%ls hrc=%Rhrc\n", this, "USBDevice::getAddress", !RT_VALID_PTR(aAddress) ? 0 : *aAddress, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Port)(USHORT *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "USBDevice::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_USBDEVICE_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(aPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_PORT_RETURN(this, hrc, 0 /*normal*/,*aPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%RU16 hrc=%Rhrc\n", this, "USBDevice::getPort", !RT_VALID_PTR(aPort) ? 0 : *aPort, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(PortPath)(BSTR *aPortPath)
{
    LogRelFlow(("{%p} %s: enter aPortPath=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_PORTPATH_RETURN(this, hrc, 0 /*normal*/,TmpPortPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_PORTPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPortPath=%ls hrc=%Rhrc\n", this, "USBDevice::getPortPath", !RT_VALID_PTR(aPortPath) ? 0 : *aPortPath, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Version)(USHORT *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "USBDevice::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_USBDEVICE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(aVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,*aVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%RU16 hrc=%Rhrc\n", this, "USBDevice::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Speed)(USBConnectionSpeed_T *aSpeed)
{
    LogRelFlow(("{%p} %s: enter aSpeed=%p\n", this, "USBDevice::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_USBDEVICE_GET_SPEED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSpeed(aSpeed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_SPEED_RETURN(this, hrc, 0 /*normal*/,*aSpeed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_SPEED_RETURN(this, hrc, 9 /*unhandled exception*/,*aSpeed);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSpeed=%RU32 hrc=%Rhrc\n", this, "USBDevice::getSpeed", !RT_VALID_PTR(aSpeed) ? 0 : *aSpeed, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Remote)(BOOL *aRemote)
{
    LogRelFlow(("{%p} %s: enter aRemote=%p\n", this, "USBDevice::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_USBDEVICE_GET_REMOTE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemote(aRemote);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_GET_REMOTE_RETURN(this, hrc, 0 /*normal*/,*aRemote != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_REMOTE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRemote != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemote=%RTbool hrc=%Rhrc\n", this, "USBDevice::getRemote", !RT_VALID_PTR(aRemote) ? 0 : *aRemote, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(DeviceInfo)(ComSafeArrayOut(BSTR, aDeviceInfo))
{
    LogRelFlow(("{%p} %s: enter aDeviceInfo=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_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_USBDEVICE_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_USBDEVICE_GET_DEVICEINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceInfo=%zu hrc=%Rhrc\n", this, "USBDevice::getDeviceInfo", !RT_VALID_PTR(aDeviceInfo) ? 0 : ComSafeArraySize(*aDeviceInfo), hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(Backend)(BSTR *aBackend)
{
    LogRelFlow(("{%p} %s: enter aBackend=%p\n", this, "USBDevice::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_USBDEVICE_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_USBDEVICE_GET_BACKEND_RETURN(this, hrc, 0 /*normal*/,TmpBackend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBDEVICE_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_USBDEVICE_GET_BACKEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBackend=%ls hrc=%Rhrc\n", this, "USBDevice::getBackend", !RT_VALID_PTR(aBackend) ? 0 : *aBackend, hrc));
    return hrc;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(InternalAndReservedAttribute1IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(InternalAndReservedAttribute2IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(InternalAndReservedAttribute3IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBDeviceWrap::COMGETTER(InternalAndReservedAttribute4IUSBDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBDevice methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(USBDeviceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBDeviceWrap, IUSBDevice)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "USBDeviceWrap.cpp"


// ##### BEGINFILE "USBProxyBackendWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUSBProxyBackend.
 *
 * 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_USBPROXYBACKEND

#include "USBProxyBackendWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(USBProxyBackendWrap)

//
// IUSBProxyBackend properties
//

STDMETHODIMP USBProxyBackendWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "USBProxyBackend::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_USBPROXYBACKEND_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_USBPROXYBACKEND_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBPROXYBACKEND_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_USBPROXYBACKEND_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "USBProxyBackend::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(Type)(BSTR *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "USBProxyBackend::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);
        BSTROutConverter TmpType(aType);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBPROXYBACKEND_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(TmpType.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBPROXYBACKEND_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,TmpType.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBPROXYBACKEND_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_USBPROXYBACKEND_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%ls hrc=%Rhrc\n", this, "USBProxyBackend::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute1IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute2IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute3IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute4IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute5IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute6IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute7IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::COMGETTER(InternalAndReservedAttribute8IUSBProxyBackend)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IUSBProxyBackend methods
//

STDMETHODIMP USBProxyBackendWrap::InternalAndReservedMethod1IUSBProxyBackend()
{
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::InternalAndReservedMethod2IUSBProxyBackend()
{
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::InternalAndReservedMethod3IUSBProxyBackend()
{
    return E_NOTIMPL;
}

STDMETHODIMP USBProxyBackendWrap::InternalAndReservedMethod4IUSBProxyBackend()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(USBProxyBackendWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBProxyBackendWrap, IUSBProxyBackend)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "USBProxyBackendWrap.cpp"


// ##### BEGINFILE "AudioAdapterWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IAudioAdapter.
 *
 * 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_AUDIOADAPTER

#include "AudioAdapterWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(AudioAdapterWrap)

//
// IAudioAdapter properties
//

STDMETHODIMP AudioAdapterWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "AudioAdapter::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_AUDIOADAPTER_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_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_AUDIOADAPTER_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "AudioAdapter::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "AudioAdapter::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_AUDIOADAPTER_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_AUDIOADAPTER_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_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_AUDIOADAPTER_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(EnabledIn)(BOOL *aEnabledIn)
{
    LogRelFlow(("{%p} %s: enter aEnabledIn=%p\n", this, "AudioAdapter::getEnabledIn", aEnabledIn));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabledIn);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabledIn(aEnabledIn);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDIN_RETURN(this, hrc, 0 /*normal*/,*aEnabledIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDIN_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabledIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabledIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabledIn=%RTbool hrc=%Rhrc\n", this, "AudioAdapter::getEnabledIn", !RT_VALID_PTR(aEnabledIn) ? 0 : *aEnabledIn, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(EnabledIn)(BOOL aEnabledIn)
{
    LogRelFlow(("{%p} %s: enter aEnabledIn=%RTbool\n", this, "AudioAdapter::setEnabledIn", aEnabledIn));

    // Clear 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_AUDIOADAPTER_SET_ENABLEDIN_ENTER(this, aEnabledIn != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabledIn(aEnabledIn != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDIN_RETURN(this, hrc, 0 /*normal*/,aEnabledIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDIN_RETURN(this, hrc, 1 /*hrc exception*/,aEnabledIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDIN_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabledIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setEnabledIn", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(EnabledOut)(BOOL *aEnabledOut)
{
    LogRelFlow(("{%p} %s: enter aEnabledOut=%p\n", this, "AudioAdapter::getEnabledOut", aEnabledOut));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabledOut);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabledOut(aEnabledOut);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDOUT_RETURN(this, hrc, 0 /*normal*/,*aEnabledOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabledOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_ENABLEDOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabledOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabledOut=%RTbool hrc=%Rhrc\n", this, "AudioAdapter::getEnabledOut", !RT_VALID_PTR(aEnabledOut) ? 0 : *aEnabledOut, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(EnabledOut)(BOOL aEnabledOut)
{
    LogRelFlow(("{%p} %s: enter aEnabledOut=%RTbool\n", this, "AudioAdapter::setEnabledOut", aEnabledOut));

    // Clear 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_AUDIOADAPTER_SET_ENABLEDOUT_ENTER(this, aEnabledOut != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabledOut(aEnabledOut != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDOUT_RETURN(this, hrc, 0 /*normal*/,aEnabledOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDOUT_RETURN(this, hrc, 1 /*hrc exception*/,aEnabledOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_ENABLEDOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabledOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setEnabledOut", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(AudioController)(AudioControllerType_T *aAudioController)
{
    LogRelFlow(("{%p} %s: enter aAudioController=%p\n", this, "AudioAdapter::getAudioController", aAudioController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAudioController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAudioController(aAudioController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aAudioController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aAudioController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aAudioController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAudioController=%RU32 hrc=%Rhrc\n", this, "AudioAdapter::getAudioController", !RT_VALID_PTR(aAudioController) ? 0 : *aAudioController, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(AudioController)(AudioControllerType_T aAudioController)
{
    LogRelFlow(("{%p} %s: enter aAudioController=%RU32\n", this, "AudioAdapter::setAudioController", aAudioController));

    // Clear 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_AUDIOADAPTER_SET_AUDIOCONTROLLER_ENTER(this, aAudioController);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioController(aAudioController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCONTROLLER_RETURN(this, hrc, 0 /*normal*/,aAudioController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,aAudioController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioController);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setAudioController", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(AudioCodec)(AudioCodecType_T *aAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aAudioCodec=%p\n", this, "AudioAdapter::getAudioCodec", aAudioCodec));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAudioCodec);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCODEC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAudioCodec(aAudioCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCODEC_RETURN(this, hrc, 0 /*normal*/,*aAudioCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,*aAudioCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,*aAudioCodec);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAudioCodec=%RU32 hrc=%Rhrc\n", this, "AudioAdapter::getAudioCodec", !RT_VALID_PTR(aAudioCodec) ? 0 : *aAudioCodec, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(AudioCodec)(AudioCodecType_T aAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aAudioCodec=%RU32\n", this, "AudioAdapter::setAudioCodec", aAudioCodec));

    // Clear 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_AUDIOADAPTER_SET_AUDIOCODEC_ENTER(this, aAudioCodec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioCodec(aAudioCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCODEC_RETURN(this, hrc, 0 /*normal*/,aAudioCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,aAudioCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioCodec);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setAudioCodec", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(AudioDriver)(AudioDriverType_T *aAudioDriver)
{
    LogRelFlow(("{%p} %s: enter aAudioDriver=%p\n", this, "AudioAdapter::getAudioDriver", aAudioDriver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAudioDriver);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIODRIVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAudioDriver(aAudioDriver);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIODRIVER_RETURN(this, hrc, 0 /*normal*/,*aAudioDriver);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIODRIVER_RETURN(this, hrc, 1 /*hrc exception*/,*aAudioDriver);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_AUDIODRIVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aAudioDriver);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAudioDriver=%RU32 hrc=%Rhrc\n", this, "AudioAdapter::getAudioDriver", !RT_VALID_PTR(aAudioDriver) ? 0 : *aAudioDriver, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMSETTER(AudioDriver)(AudioDriverType_T aAudioDriver)
{
    LogRelFlow(("{%p} %s: enter aAudioDriver=%RU32\n", this, "AudioAdapter::setAudioDriver", aAudioDriver));

    // Clear 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_AUDIOADAPTER_SET_AUDIODRIVER_ENTER(this, aAudioDriver);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAudioDriver(aAudioDriver);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIODRIVER_RETURN(this, hrc, 0 /*normal*/,aAudioDriver);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIODRIVER_RETURN(this, hrc, 1 /*hrc exception*/,aAudioDriver);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SET_AUDIODRIVER_RETURN(this, hrc, 9 /*unhandled exception*/,aAudioDriver);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setAudioDriver", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(PropertiesList)(ComSafeArrayOut(BSTR, aPropertiesList))
{
    LogRelFlow(("{%p} %s: enter aPropertiesList=%p\n", this, "AudioAdapter::getPropertiesList", aPropertiesList));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPropertiesList);
        ArrayBSTROutConverter TmpPropertiesList(ComSafeArrayOutArg(aPropertiesList));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_PROPERTIESLIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPropertiesList(TmpPropertiesList.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_PROPERTIESLIST_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPropertiesList.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_PROPERTIESLIST_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GET_PROPERTIESLIST_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPropertiesList=%zu hrc=%Rhrc\n", this, "AudioAdapter::getPropertiesList", !RT_VALID_PTR(aPropertiesList) ? 0 : ComSafeArraySize(*aPropertiesList), hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute1IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute2IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute3IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute4IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute5IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute6IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute7IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::COMGETTER(InternalAndReservedAttribute8IAudioAdapter)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IAudioAdapter methods
//

STDMETHODIMP AudioAdapterWrap::SetProperty(IN_BSTR aKey,
                                           IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%ls\n", this, "AudioAdapter::setProperty", 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_AUDIOADAPTER_SETPROPERTY_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProperty(TmpKey.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_SETPROPERTY_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_AUDIOADAPTER_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_AUDIOADAPTER_SETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "AudioAdapter::setProperty", hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::GetProperty(IN_BSTR aKey,
                                           BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "AudioAdapter::getProperty", 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_AUDIOADAPTER_GETPROPERTY_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperty(TmpKey.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_AUDIOADAPTER_GETPROPERTY_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_AUDIOADAPTER_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_AUDIOADAPTER_GETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "AudioAdapter::getProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP AudioAdapterWrap::InternalAndReservedMethod1IAudioAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::InternalAndReservedMethod2IAudioAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::InternalAndReservedMethod3IAudioAdapter()
{
    return E_NOTIMPL;
}

STDMETHODIMP AudioAdapterWrap::InternalAndReservedMethod4IAudioAdapter()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(AudioAdapterWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AudioAdapterWrap, IAudioAdapter)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "AudioAdapterWrap.cpp"


// ##### BEGINFILE "HostAudioDeviceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostAudioDevice.
 *
 * 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_HOSTAUDIODEVICE

#include "HostAudioDeviceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(HostAudioDeviceWrap)

//
// IHostAudioDevice properties
//

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "HostAudioDevice::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "HostAudioDevice::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setName", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(Type)(AudioDeviceType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "HostAudioDevice::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(Type)(AudioDeviceType_T aType)
{
    LogRelFlow(("{%p} %s: enter aType=%RU32\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_SET_TYPE_RETURN(this, hrc, 0 /*normal*/,aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_SET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setType", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(Usage)(AudioDirection_T *aUsage)
{
    LogRelFlow(("{%p} %s: enter aUsage=%p\n", this, "HostAudioDevice::getUsage", 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
    {
        CheckComArgOutPointerValidThrow(aUsage);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_USAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsage(aUsage);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_USAGE_RETURN(this, hrc, 0 /*normal*/,*aUsage);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_USAGE_RETURN(this, hrc, 1 /*hrc exception*/,*aUsage);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_USAGE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsage);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsage=%RU32 hrc=%Rhrc\n", this, "HostAudioDevice::getUsage", !RT_VALID_PTR(aUsage) ? 0 : *aUsage, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(Usage)(AudioDirection_T aUsage)
{
    LogRelFlow(("{%p} %s: enter aUsage=%RU32\n", this, "HostAudioDevice::setUsage", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_USAGE_ENTER(this, aUsage);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUsage(aUsage);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_USAGE_RETURN(this, hrc, 0 /*normal*/,aUsage);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_USAGE_RETURN(this, hrc, 1 /*hrc exception*/,aUsage);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_USAGE_RETURN(this, hrc, 9 /*unhandled exception*/,aUsage);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setUsage", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(DefaultIn)(BOOL *aDefaultIn)
{
    LogRelFlow(("{%p} %s: enter aDefaultIn=%p\n", this, "HostAudioDevice::getDefaultIn", aDefaultIn));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultIn);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultIn(aDefaultIn);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTIN_RETURN(this, hrc, 0 /*normal*/,*aDefaultIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTIN_RETURN(this, hrc, 1 /*hrc exception*/,*aDefaultIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultIn=%RTbool hrc=%Rhrc\n", this, "HostAudioDevice::getDefaultIn", !RT_VALID_PTR(aDefaultIn) ? 0 : *aDefaultIn, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(DefaultIn)(BOOL aDefaultIn)
{
    LogRelFlow(("{%p} %s: enter aDefaultIn=%RTbool\n", this, "HostAudioDevice::setDefaultIn", aDefaultIn));

    // Clear 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_HOSTAUDIODEVICE_SET_DEFAULTIN_ENTER(this, aDefaultIn != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultIn(aDefaultIn != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTIN_RETURN(this, hrc, 0 /*normal*/,aDefaultIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTIN_RETURN(this, hrc, 1 /*hrc exception*/,aDefaultIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTIN_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultIn != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setDefaultIn", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(DefaultOut)(BOOL *aDefaultOut)
{
    LogRelFlow(("{%p} %s: enter aDefaultOut=%p\n", this, "HostAudioDevice::getDefaultOut", aDefaultOut));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDefaultOut);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDefaultOut(aDefaultOut);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTOUT_RETURN(this, hrc, 0 /*normal*/,*aDefaultOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aDefaultOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_DEFAULTOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aDefaultOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDefaultOut=%RTbool hrc=%Rhrc\n", this, "HostAudioDevice::getDefaultOut", !RT_VALID_PTR(aDefaultOut) ? 0 : *aDefaultOut, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(DefaultOut)(BOOL aDefaultOut)
{
    LogRelFlow(("{%p} %s: enter aDefaultOut=%RTbool\n", this, "HostAudioDevice::setDefaultOut", aDefaultOut));

    // Clear 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_HOSTAUDIODEVICE_SET_DEFAULTOUT_ENTER(this, aDefaultOut != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDefaultOut(aDefaultOut != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTOUT_RETURN(this, hrc, 0 /*normal*/,aDefaultOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTOUT_RETURN(this, hrc, 1 /*hrc exception*/,aDefaultOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_DEFAULTOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aDefaultOut != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setDefaultOut", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(IsHotPlug)(BOOL *aIsHotPlug)
{
    LogRelFlow(("{%p} %s: enter aIsHotPlug=%p\n", this, "HostAudioDevice::getIsHotPlug", aIsHotPlug));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsHotPlug);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_ISHOTPLUG_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsHotPlug(aIsHotPlug);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_ISHOTPLUG_RETURN(this, hrc, 0 /*normal*/,*aIsHotPlug != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_ISHOTPLUG_RETURN(this, hrc, 1 /*hrc exception*/,*aIsHotPlug != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_ISHOTPLUG_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsHotPlug != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsHotPlug=%RTbool hrc=%Rhrc\n", this, "HostAudioDevice::getIsHotPlug", !RT_VALID_PTR(aIsHotPlug) ? 0 : *aIsHotPlug, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(IsHotPlug)(BOOL aIsHotPlug)
{
    LogRelFlow(("{%p} %s: enter aIsHotPlug=%RTbool\n", this, "HostAudioDevice::setIsHotPlug", aIsHotPlug));

    // Clear 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_HOSTAUDIODEVICE_SET_ISHOTPLUG_ENTER(this, aIsHotPlug != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIsHotPlug(aIsHotPlug != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_ISHOTPLUG_RETURN(this, hrc, 0 /*normal*/,aIsHotPlug != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_ISHOTPLUG_RETURN(this, hrc, 1 /*hrc exception*/,aIsHotPlug != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_ISHOTPLUG_RETURN(this, hrc, 9 /*unhandled exception*/,aIsHotPlug != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setIsHotPlug", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(State)(AudioDeviceState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "HostAudioDevice::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_HOSTAUDIODEVICE_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "HostAudioDevice::getState", !RT_VALID_PTR(aState) ? 0 : *aState, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMSETTER(State)(AudioDeviceState_T aState)
{
    LogRelFlow(("{%p} %s: enter aState=%RU32\n", this, "HostAudioDevice::setState", 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_HOSTAUDIODEVICE_SET_STATE_ENTER(this, aState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_STATE_RETURN(this, hrc, 0 /*normal*/,aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_SET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostAudioDevice::setState", hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute1IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute2IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute3IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute4IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute5IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute6IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute7IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::COMGETTER(InternalAndReservedAttribute8IHostAudioDevice)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostAudioDevice methods
//

STDMETHODIMP HostAudioDeviceWrap::GetProperty(IN_BSTR aKey,
                                              BSTR *aValue)
{
    LogRelFlow(("{%p} %s: enter aKey=%ls aValue=%p\n", this, "HostAudioDevice::getProperty", 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_HOSTAUDIODEVICE_GETPROPERTY_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProperty(TmpKey.str(),
                              TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_HOSTAUDIODEVICE_GETPROPERTY_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_HOSTAUDIODEVICE_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_HOSTAUDIODEVICE_GETPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "HostAudioDevice::getProperty", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP HostAudioDeviceWrap::InternalAndReservedMethod1IHostAudioDevice()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::InternalAndReservedMethod2IHostAudioDevice()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::InternalAndReservedMethod3IHostAudioDevice()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostAudioDeviceWrap::InternalAndReservedMethod4IHostAudioDevice()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostAudioDeviceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostAudioDeviceWrap, IHostAudioDevice)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostAudioDeviceWrap.cpp"


// ##### BEGINFILE "SharedFolderWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISharedFolder.
 *
 * 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_SHAREDFOLDER

#include "SharedFolderWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SharedFolderWrap)

//
// ISharedFolder properties
//

STDMETHODIMP SharedFolderWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "SharedFolder::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_SHAREDFOLDER_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_SHAREDFOLDER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_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_SHAREDFOLDER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "SharedFolder::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(HostPath)(BSTR *aHostPath)
{
    LogRelFlow(("{%p} %s: enter aHostPath=%p\n", this, "SharedFolder::getHostPath", aHostPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostPath);
        BSTROutConverter TmpHostPath(aHostPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_HOSTPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostPath(TmpHostPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_HOSTPATH_RETURN(this, hrc, 0 /*normal*/,TmpHostPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_HOSTPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_HOSTPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostPath=%ls hrc=%Rhrc\n", this, "SharedFolder::getHostPath", !RT_VALID_PTR(aHostPath) ? 0 : *aHostPath, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(Accessible)(BOOL *aAccessible)
{
    LogRelFlow(("{%p} %s: enter aAccessible=%p\n", this, "SharedFolder::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_SHAREDFOLDER_GET_ACCESSIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessible(aAccessible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_ACCESSIBLE_RETURN(this, hrc, 0 /*normal*/,*aAccessible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_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_SHAREDFOLDER_GET_ACCESSIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessible=%RTbool hrc=%Rhrc\n", this, "SharedFolder::getAccessible", !RT_VALID_PTR(aAccessible) ? 0 : *aAccessible, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(Writable)(BOOL *aWritable)
{
    LogRelFlow(("{%p} %s: enter aWritable=%p\n", this, "SharedFolder::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_SHAREDFOLDER_GET_WRITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWritable(aWritable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_WRITABLE_RETURN(this, hrc, 0 /*normal*/,*aWritable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_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_SHAREDFOLDER_GET_WRITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWritable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWritable=%RTbool hrc=%Rhrc\n", this, "SharedFolder::getWritable", !RT_VALID_PTR(aWritable) ? 0 : *aWritable, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMSETTER(Writable)(BOOL aWritable)
{
    LogRelFlow(("{%p} %s: enter aWritable=%RTbool\n", this, "SharedFolder::setWritable", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_WRITABLE_ENTER(this, aWritable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setWritable(aWritable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_WRITABLE_RETURN(this, hrc, 0 /*normal*/,aWritable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_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_SHAREDFOLDER_SET_WRITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,aWritable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SharedFolder::setWritable", hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(AutoMount)(BOOL *aAutoMount)
{
    LogRelFlow(("{%p} %s: enter aAutoMount=%p\n", this, "SharedFolder::getAutoMount", aAutoMount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAutoMount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutoMount(aAutoMount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNT_RETURN(this, hrc, 0 /*normal*/,*aAutoMount != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aAutoMount != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aAutoMount != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutoMount=%RTbool hrc=%Rhrc\n", this, "SharedFolder::getAutoMount", !RT_VALID_PTR(aAutoMount) ? 0 : *aAutoMount, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMSETTER(AutoMount)(BOOL aAutoMount)
{
    LogRelFlow(("{%p} %s: enter aAutoMount=%RTbool\n", this, "SharedFolder::setAutoMount", aAutoMount));

    // Clear 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_SHAREDFOLDER_SET_AUTOMOUNT_ENTER(this, aAutoMount != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutoMount(aAutoMount != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNT_RETURN(this, hrc, 0 /*normal*/,aAutoMount != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aAutoMount != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aAutoMount != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SharedFolder::setAutoMount", hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(AutoMountPoint)(BSTR *aAutoMountPoint)
{
    LogRelFlow(("{%p} %s: enter aAutoMountPoint=%p\n", this, "SharedFolder::getAutoMountPoint", 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
    {
        CheckComArgOutPointerValidThrow(aAutoMountPoint);
        BSTROutConverter TmpAutoMountPoint(aAutoMountPoint);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNTPOINT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAutoMountPoint(TmpAutoMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNTPOINT_RETURN(this, hrc, 0 /*normal*/,TmpAutoMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNTPOINT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_AUTOMOUNTPOINT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAutoMountPoint=%ls hrc=%Rhrc\n", this, "SharedFolder::getAutoMountPoint", !RT_VALID_PTR(aAutoMountPoint) ? 0 : *aAutoMountPoint, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMSETTER(AutoMountPoint)(IN_BSTR aAutoMountPoint)
{
    LogRelFlow(("{%p} %s: enter aAutoMountPoint=%ls\n", this, "SharedFolder::setAutoMountPoint", 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 TmpAutoMountPoint(aAutoMountPoint);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNTPOINT_ENTER(this, TmpAutoMountPoint.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAutoMountPoint(TmpAutoMountPoint.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNTPOINT_RETURN(this, hrc, 0 /*normal*/,TmpAutoMountPoint.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNTPOINT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_AUTOMOUNTPOINT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SharedFolder::setAutoMountPoint", hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(LastAccessError)(BSTR *aLastAccessError)
{
    LogRelFlow(("{%p} %s: enter aLastAccessError=%p\n", this, "SharedFolder::getLastAccessError", aLastAccessError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastAccessError);
        BSTROutConverter TmpLastAccessError(aLastAccessError);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_LASTACCESSERROR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastAccessError(TmpLastAccessError.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_LASTACCESSERROR_RETURN(this, hrc, 0 /*normal*/,TmpLastAccessError.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_LASTACCESSERROR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_LASTACCESSERROR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastAccessError=%ls hrc=%Rhrc\n", this, "SharedFolder::getLastAccessError", !RT_VALID_PTR(aLastAccessError) ? 0 : *aLastAccessError, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(SymlinkPolicy)(SymlinkPolicy_T *aSymlinkPolicy)
{
    LogRelFlow(("{%p} %s: enter aSymlinkPolicy=%p\n", this, "SharedFolder::getSymlinkPolicy", aSymlinkPolicy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSymlinkPolicy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_SYMLINKPOLICY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSymlinkPolicy(aSymlinkPolicy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_SYMLINKPOLICY_RETURN(this, hrc, 0 /*normal*/,*aSymlinkPolicy);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_SYMLINKPOLICY_RETURN(this, hrc, 1 /*hrc exception*/,*aSymlinkPolicy);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_GET_SYMLINKPOLICY_RETURN(this, hrc, 9 /*unhandled exception*/,*aSymlinkPolicy);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSymlinkPolicy=%RU32 hrc=%Rhrc\n", this, "SharedFolder::getSymlinkPolicy", !RT_VALID_PTR(aSymlinkPolicy) ? 0 : *aSymlinkPolicy, hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMSETTER(SymlinkPolicy)(SymlinkPolicy_T aSymlinkPolicy)
{
    LogRelFlow(("{%p} %s: enter aSymlinkPolicy=%RU32\n", this, "SharedFolder::setSymlinkPolicy", aSymlinkPolicy));

    // Clear 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_SHAREDFOLDER_SET_SYMLINKPOLICY_ENTER(this, aSymlinkPolicy);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSymlinkPolicy(aSymlinkPolicy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_SYMLINKPOLICY_RETURN(this, hrc, 0 /*normal*/,aSymlinkPolicy);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_SYMLINKPOLICY_RETURN(this, hrc, 1 /*hrc exception*/,aSymlinkPolicy);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SHAREDFOLDER_SET_SYMLINKPOLICY_RETURN(this, hrc, 9 /*unhandled exception*/,aSymlinkPolicy);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SharedFolder::setSymlinkPolicy", hrc));
    return hrc;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute1ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute2ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute3ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute4ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute5ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute6ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute7ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SharedFolderWrap::COMGETTER(InternalAndReservedAttribute8ISharedFolder)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISharedFolder methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SharedFolderWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolderWrap, ISharedFolder)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SharedFolderWrap.cpp"


// ##### BEGINFILE "PerformanceCollectorWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPerformanceCollector.
 *
 * 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_PERFORMANCECOLLECTOR

#include "PerformanceCollectorWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PerformanceCollectorWrap)

//
// IPerformanceCollector properties
//

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(MetricNames)(ComSafeArrayOut(BSTR, aMetricNames))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%p\n", this, "PerformanceCollector::getMetricNames", aMetricNames));

    // Clear error 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);
        ArrayBSTROutConverter TmpMetricNames(ComSafeArrayOutArg(aMetricNames));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GET_METRICNAMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMetricNames(TmpMetricNames.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GET_METRICNAMES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpMetricNames.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GET_METRICNAMES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GET_METRICNAMES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMetricNames=%zu hrc=%Rhrc\n", this, "PerformanceCollector::getMetricNames", !RT_VALID_PTR(aMetricNames) ? 0 : ComSafeArraySize(*aMetricNames), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute1IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute2IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute3IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute4IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute5IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute6IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute7IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::COMGETTER(InternalAndReservedAttribute8IPerformanceCollector)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPerformanceCollector methods
//

STDMETHODIMP PerformanceCollectorWrap::GetMetrics(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                                  ComSafeArrayIn(IUnknown *, aObjects),
                                                  ComSafeArrayOut(IPerformanceMetric *, aMetrics))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%zu aObjects=%zu aMetrics=%p\n", this, "PerformanceCollector::getMetrics", aMetricNames, aObjects, aMetrics));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMetrics);


        ArrayBSTRInConverter TmpMetricNames(ComSafeArrayInArg(aMetricNames));
        ArrayComTypeInConverter<IUnknown> TmpObjects(ComSafeArrayInArg(aObjects));
        ArrayComTypeOutConverter<IPerformanceMetric> TmpMetrics(ComSafeArrayOutArg(aMetrics));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GETMETRICS_ENTER(this, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMetrics(TmpMetricNames.array(),
                             TmpObjects.array(),
                             TmpMetrics.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GETMETRICS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, (uint32_t)TmpMetrics.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_GETMETRICS_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_PERFORMANCECOLLECTOR_GETMETRICS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMetrics=%zu hrc=%Rhrc\n", this, "PerformanceCollector::getMetrics", !RT_VALID_PTR(aMetrics) ? 0 : ComSafeArraySize(*aMetrics), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::SetupMetrics(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                                    ComSafeArrayIn(IUnknown *, aObjects),
                                                    ULONG aPeriod,
                                                    ULONG aCount,
                                                    ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%zu aObjects=%zu aPeriod=%RU32 aCount=%RU32 aAffectedMetrics=%p\n", this, "PerformanceCollector::setupMetrics", aMetricNames, aObjects, aPeriod, aCount, aAffectedMetrics));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAffectedMetrics);


        ArrayBSTRInConverter TmpMetricNames(ComSafeArrayInArg(aMetricNames));
        ArrayComTypeInConverter<IUnknown> TmpObjects(ComSafeArrayInArg(aObjects));
        
        
        ArrayComTypeOutConverter<IPerformanceMetric> TmpAffectedMetrics(ComSafeArrayOutArg(aAffectedMetrics));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_SETUPMETRICS_ENTER(this, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, aPeriod, aCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setupMetrics(TmpMetricNames.array(),
                               TmpObjects.array(),
                               aPeriod,
                               aCount,
                               TmpAffectedMetrics.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_SETUPMETRICS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, aPeriod, aCount, (uint32_t)TmpAffectedMetrics.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_SETUPMETRICS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, aPeriod, aCount, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_SETUPMETRICS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, aPeriod, aCount, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAffectedMetrics=%zu hrc=%Rhrc\n", this, "PerformanceCollector::setupMetrics", !RT_VALID_PTR(aAffectedMetrics) ? 0 : ComSafeArraySize(*aAffectedMetrics), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::EnableMetrics(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                                     ComSafeArrayIn(IUnknown *, aObjects),
                                                     ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%zu aObjects=%zu aAffectedMetrics=%p\n", this, "PerformanceCollector::enableMetrics", aMetricNames, aObjects, aAffectedMetrics));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAffectedMetrics);


        ArrayBSTRInConverter TmpMetricNames(ComSafeArrayInArg(aMetricNames));
        ArrayComTypeInConverter<IUnknown> TmpObjects(ComSafeArrayInArg(aObjects));
        ArrayComTypeOutConverter<IPerformanceMetric> TmpAffectedMetrics(ComSafeArrayOutArg(aAffectedMetrics));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_ENABLEMETRICS_ENTER(this, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = enableMetrics(TmpMetricNames.array(),
                                TmpObjects.array(),
                                TmpAffectedMetrics.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_ENABLEMETRICS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, (uint32_t)TmpAffectedMetrics.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_ENABLEMETRICS_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_PERFORMANCECOLLECTOR_ENABLEMETRICS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAffectedMetrics=%zu hrc=%Rhrc\n", this, "PerformanceCollector::enableMetrics", !RT_VALID_PTR(aAffectedMetrics) ? 0 : ComSafeArraySize(*aAffectedMetrics), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::DisableMetrics(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                                      ComSafeArrayIn(IUnknown *, aObjects),
                                                      ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%zu aObjects=%zu aAffectedMetrics=%p\n", this, "PerformanceCollector::disableMetrics", aMetricNames, aObjects, aAffectedMetrics));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAffectedMetrics);


        ArrayBSTRInConverter TmpMetricNames(ComSafeArrayInArg(aMetricNames));
        ArrayComTypeInConverter<IUnknown> TmpObjects(ComSafeArrayInArg(aObjects));
        ArrayComTypeOutConverter<IPerformanceMetric> TmpAffectedMetrics(ComSafeArrayOutArg(aAffectedMetrics));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_DISABLEMETRICS_ENTER(this, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = disableMetrics(TmpMetricNames.array(),
                                 TmpObjects.array(),
                                 TmpAffectedMetrics.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_DISABLEMETRICS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, (uint32_t)TmpAffectedMetrics.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_DISABLEMETRICS_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_PERFORMANCECOLLECTOR_DISABLEMETRICS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aAffectedMetrics=%zu hrc=%Rhrc\n", this, "PerformanceCollector::disableMetrics", !RT_VALID_PTR(aAffectedMetrics) ? 0 : ComSafeArraySize(*aAffectedMetrics), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::QueryMetricsData(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                                        ComSafeArrayIn(IUnknown *, aObjects),
                                                        ComSafeArrayOut(BSTR, aReturnMetricNames),
                                                        ComSafeArrayOut(IUnknown *, aReturnObjects),
                                                        ComSafeArrayOut(BSTR, aReturnUnits),
                                                        ComSafeArrayOut(ULONG, aReturnScales),
                                                        ComSafeArrayOut(ULONG, aReturnSequenceNumbers),
                                                        ComSafeArrayOut(ULONG, aReturnDataIndices),
                                                        ComSafeArrayOut(ULONG, aReturnDataLengths),
                                                        ComSafeArrayOut(LONG, aReturnData))
{
    LogRelFlow(("{%p} %s: enter aMetricNames=%zu aObjects=%zu aReturnMetricNames=%p aReturnObjects=%p aReturnUnits=%p aReturnScales=%p aReturnSequenceNumbers=%p aReturnDataIndices=%p aReturnDataLengths=%p aReturnData=%p\n", this, "PerformanceCollector::queryMetricsData", aMetricNames, aObjects, aReturnMetricNames, aReturnObjects, aReturnUnits, aReturnScales, aReturnSequenceNumbers, aReturnDataIndices, aReturnDataLengths, aReturnData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReturnMetricNames);
        CheckComArgOutPointerValidThrow(aReturnObjects);
        CheckComArgOutPointerValidThrow(aReturnUnits);
        CheckComArgOutPointerValidThrow(aReturnScales);
        CheckComArgOutPointerValidThrow(aReturnSequenceNumbers);
        CheckComArgOutPointerValidThrow(aReturnDataIndices);
        CheckComArgOutPointerValidThrow(aReturnDataLengths);
        CheckComArgOutPointerValidThrow(aReturnData);


        ArrayBSTRInConverter TmpMetricNames(ComSafeArrayInArg(aMetricNames));
        ArrayComTypeInConverter<IUnknown> TmpObjects(ComSafeArrayInArg(aObjects));
        ArrayBSTROutConverter TmpReturnMetricNames(ComSafeArrayOutArg(aReturnMetricNames));
        ArrayComTypeOutConverter<IUnknown> TmpReturnObjects(ComSafeArrayOutArg(aReturnObjects));
        ArrayBSTROutConverter TmpReturnUnits(ComSafeArrayOutArg(aReturnUnits));
        ArrayOutConverter<ULONG> TmpReturnScales(ComSafeArrayOutArg(aReturnScales));
        ArrayOutConverter<ULONG> TmpReturnSequenceNumbers(ComSafeArrayOutArg(aReturnSequenceNumbers));
        ArrayOutConverter<ULONG> TmpReturnDataIndices(ComSafeArrayOutArg(aReturnDataIndices));
        ArrayOutConverter<ULONG> TmpReturnDataLengths(ComSafeArrayOutArg(aReturnDataLengths));
        ArrayOutConverter<LONG> TmpReturnData(ComSafeArrayOutArg(aReturnData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_QUERYMETRICSDATA_ENTER(this, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryMetricsData(TmpMetricNames.array(),
                                   TmpObjects.array(),
                                   TmpReturnMetricNames.array(),
                                   TmpReturnObjects.array(),
                                   TmpReturnUnits.array(),
                                   TmpReturnScales.array(),
                                   TmpReturnSequenceNumbers.array(),
                                   TmpReturnDataIndices.array(),
                                   TmpReturnDataLengths.array(),
                                   TmpReturnData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_QUERYMETRICSDATA_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpObjects.array().size(), NULL /*for now*/, (uint32_t)TmpReturnMetricNames.array().size(), NULL /*for now*/, (uint32_t)TmpReturnObjects.array().size(), NULL /*for now*/, (uint32_t)TmpReturnUnits.array().size(), NULL /*for now*/, (uint32_t)TmpReturnScales.array().size(), NULL /*for now*/, (uint32_t)TmpReturnSequenceNumbers.array().size(), NULL /*for now*/, (uint32_t)TmpReturnDataIndices.array().size(), NULL /*for now*/, (uint32_t)TmpReturnDataLengths.array().size(), NULL /*for now*/, (uint32_t)TmpReturnData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCECOLLECTOR_QUERYMETRICSDATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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_PERFORMANCECOLLECTOR_QUERYMETRICSDATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnMetricNames=%zu *aReturnObjects=%zu *aReturnUnits=%zu *aReturnScales=%zu *aReturnSequenceNumbers=%zu *aReturnDataIndices=%zu *aReturnDataLengths=%zu aReturnData=%zu hrc=%Rhrc\n", this, "PerformanceCollector::queryMetricsData", !RT_VALID_PTR(aReturnMetricNames) ? 0 : ComSafeArraySize(*aReturnMetricNames), !RT_VALID_PTR(aReturnObjects) ? 0 : ComSafeArraySize(*aReturnObjects), !RT_VALID_PTR(aReturnUnits) ? 0 : ComSafeArraySize(*aReturnUnits), !RT_VALID_PTR(aReturnScales) ? 0 : ComSafeArraySize(*aReturnScales), !RT_VALID_PTR(aReturnSequenceNumbers) ? 0 : ComSafeArraySize(*aReturnSequenceNumbers), !RT_VALID_PTR(aReturnDataIndices) ? 0 : ComSafeArraySize(*aReturnDataIndices), !RT_VALID_PTR(aReturnDataLengths) ? 0 : ComSafeArraySize(*aReturnDataLengths), !RT_VALID_PTR(aReturnData) ? 0 : ComSafeArraySize(*aReturnData), hrc));
    return hrc;
}

STDMETHODIMP PerformanceCollectorWrap::InternalAndReservedMethod1IPerformanceCollector()
{
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::InternalAndReservedMethod2IPerformanceCollector()
{
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::InternalAndReservedMethod3IPerformanceCollector()
{
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceCollectorWrap::InternalAndReservedMethod4IPerformanceCollector()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PerformanceCollectorWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceCollectorWrap, IPerformanceCollector)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PerformanceCollectorWrap.cpp"


// ##### BEGINFILE "ExtPackPlugInWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackPlugIn.
 *
 * 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_EXTPACKPLUGIN

#include "ExtPackPlugInWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackPlugInWrap)

//
// IExtPackPlugIn properties
//

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPackPlugIn::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_EXTPACKPLUGIN_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_EXTPACKPLUGIN_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_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_EXTPACKPLUGIN_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPackPlugIn::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPackPlugIn::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_EXTPACKPLUGIN_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_EXTPACKPLUGIN_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_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_EXTPACKPLUGIN_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPackPlugIn::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(Frontend)(BSTR *aFrontend)
{
    LogRelFlow(("{%p} %s: enter aFrontend=%p\n", this, "ExtPackPlugIn::getFrontend", aFrontend));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFrontend);
        BSTROutConverter TmpFrontend(aFrontend);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_FRONTEND_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFrontend(TmpFrontend.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_FRONTEND_RETURN(this, hrc, 0 /*normal*/,TmpFrontend.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_FRONTEND_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_FRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFrontend=%ls hrc=%Rhrc\n", this, "ExtPackPlugIn::getFrontend", !RT_VALID_PTR(aFrontend) ? 0 : *aFrontend, hrc));
    return hrc;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(ModulePath)(BSTR *aModulePath)
{
    LogRelFlow(("{%p} %s: enter aModulePath=%p\n", this, "ExtPackPlugIn::getModulePath", aModulePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aModulePath);
        BSTROutConverter TmpModulePath(aModulePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_MODULEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getModulePath(TmpModulePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_MODULEPATH_RETURN(this, hrc, 0 /*normal*/,TmpModulePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_MODULEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKPLUGIN_GET_MODULEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aModulePath=%ls hrc=%Rhrc\n", this, "ExtPackPlugIn::getModulePath", !RT_VALID_PTR(aModulePath) ? 0 : *aModulePath, hrc));
    return hrc;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(InternalAndReservedAttribute1IExtPackPlugIn)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(InternalAndReservedAttribute2IExtPackPlugIn)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(InternalAndReservedAttribute3IExtPackPlugIn)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackPlugInWrap::COMGETTER(InternalAndReservedAttribute4IExtPackPlugIn)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackPlugIn methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackPlugInWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackPlugInWrap, IExtPackPlugIn)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackPlugInWrap.cpp"


// ##### BEGINFILE "ExtPackWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPack.
 *
 * 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_EXTPACK

#include "ExtPackWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackWrap)

//
// IExtPackBase properties
//

STDMETHODIMP ExtPackWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPack::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPack::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "ExtPack::getVersion", !RT_VALID_PTR(aVersion) ? 0 : *aVersion, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPack::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_EXTPACK_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPack::getRevision", !RT_VALID_PTR(aRevision) ? 0 : *aRevision, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(Edition)(BSTR *aEdition)
{
    LogRelFlow(("{%p} %s: enter aEdition=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_EDITION_RETURN(this, hrc, 0 /*normal*/,TmpEdition.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_EDITION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEdition=%ls hrc=%Rhrc\n", this, "ExtPack::getEdition", !RT_VALID_PTR(aEdition) ? 0 : *aEdition, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(VRDEModule)(BSTR *aVRDEModule)
{
    LogRelFlow(("{%p} %s: enter aVRDEModule=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_VRDEMODULE_RETURN(this, hrc, 0 /*normal*/,TmpVRDEModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_VRDEMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEModule=%ls hrc=%Rhrc\n", this, "ExtPack::getVRDEModule", !RT_VALID_PTR(aVRDEModule) ? 0 : *aVRDEModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(CryptoModule)(BSTR *aCryptoModule)
{
    LogRelFlow(("{%p} %s: enter aCryptoModule=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_CRYPTOMODULE_RETURN(this, hrc, 0 /*normal*/,TmpCryptoModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_CRYPTOMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCryptoModule=%ls hrc=%Rhrc\n", this, "ExtPack::getCryptoModule", !RT_VALID_PTR(aCryptoModule) ? 0 : *aCryptoModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(PlugIns)(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns))
{
    LogRelFlow(("{%p} %s: enter aPlugIns=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_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_EXTPACK_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_EXTPACK_GET_PLUGINS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlugIns=%zu hrc=%Rhrc\n", this, "ExtPack::getPlugIns", !RT_VALID_PTR(aPlugIns) ? 0 : ComSafeArraySize(*aPlugIns), hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(Usable)(BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aUsable=%p\n", this, "ExtPack::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_EXTPACK_GET_USABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsable(aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_GET_USABLE_RETURN(this, hrc, 0 /*normal*/,*aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_USABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPack::getUsable", !RT_VALID_PTR(aUsable) ? 0 : *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(WhyUnusable)(BSTR *aWhyUnusable)
{
    LogRelFlow(("{%p} %s: enter aWhyUnusable=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_WHYUNUSABLE_RETURN(this, hrc, 0 /*normal*/,TmpWhyUnusable.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_WHYUNUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWhyUnusable=%ls hrc=%Rhrc\n", this, "ExtPack::getWhyUnusable", !RT_VALID_PTR(aWhyUnusable) ? 0 : *aWhyUnusable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(ShowLicense)(BOOL *aShowLicense)
{
    LogRelFlow(("{%p} %s: enter aShowLicense=%p\n", this, "ExtPack::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_EXTPACK_GET_SHOWLICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShowLicense(aShowLicense);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_GET_SHOWLICENSE_RETURN(this, hrc, 0 /*normal*/,*aShowLicense != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_SHOWLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,*aShowLicense != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShowLicense=%RTbool hrc=%Rhrc\n", this, "ExtPack::getShowLicense", !RT_VALID_PTR(aShowLicense) ? 0 : *aShowLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(License)(BSTR *aLicense)
{
    LogRelFlow(("{%p} %s: enter aLicense=%p\n", this, "ExtPack::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_EXTPACK_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_EXTPACK_GET_LICENSE_RETURN(this, hrc, 0 /*normal*/,TmpLicense.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_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_EXTPACK_GET_LICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLicense=%ls hrc=%Rhrc\n", this, "ExtPack::getLicense", !RT_VALID_PTR(aLicense) ? 0 : *aLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute1IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute2IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute3IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute4IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute5IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute6IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute7IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::COMGETTER(InternalAndReservedAttribute8IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IExtPack properties
//


//
// IExtPackBase methods
//

STDMETHODIMP ExtPackWrap::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, "ExtPack::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_EXTPACK_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_EXTPACK_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_EXTPACK_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_EXTPACK_QUERYLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLicenseText=%ls hrc=%Rhrc\n", this, "ExtPack::queryLicense", !RT_VALID_PTR(aLicenseText) ? 0 : *aLicenseText, hrc));
    return hrc;
}

STDMETHODIMP ExtPackWrap::InternalAndReservedMethod1IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::InternalAndReservedMethod2IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::InternalAndReservedMethod3IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackWrap::InternalAndReservedMethod4IExtPackBase()
{
    return E_NOTIMPL;
}

//
// IExtPack methods
//

STDMETHODIMP ExtPackWrap::QueryObject(IN_BSTR aObjUuid,
                                      IUnknown **aReturnInterface)
{
    LogRelFlow(("{%p} %s: enter aObjUuid=%ls aReturnInterface=%p\n", this, "ExtPack::queryObject", aObjUuid, aReturnInterface));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReturnInterface);


        BSTRInConverter TmpObjUuid(aObjUuid);
        ComTypeOutConverter<IUnknown> TmpReturnInterface(aReturnInterface);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_QUERYOBJECT_ENTER(this, TmpObjUuid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryObject(TmpObjUuid.str(),
                              TmpReturnInterface.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_QUERYOBJECT_RETURN(this, hrc, 0 /*normal*/, TmpObjUuid.str().c_str(), (void *)TmpReturnInterface.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_QUERYOBJECT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACK_QUERYOBJECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReturnInterface=%p hrc=%Rhrc\n", this, "ExtPack::queryObject", !RT_VALID_PTR(aReturnInterface) ? 0 : *aReturnInterface, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ExtPackWrap, IExtPack, IExtPackBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackWrap.cpp"


// ##### BEGINFILE "ExtPackManagerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackManager.
 *
 * 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_EXTPACKMANAGER

#include "ExtPackManagerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackManagerWrap)

//
// IExtPackManager properties
//

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InstalledExtPacks)(ComSafeArrayOut(IExtPack *, aInstalledExtPacks))
{
    LogRelFlow(("{%p} %s: enter aInstalledExtPacks=%p\n", this, "ExtPackManager::getInstalledExtPacks", aInstalledExtPacks));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInstalledExtPacks);
        ArrayComTypeOutConverter<IExtPack> TmpInstalledExtPacks(ComSafeArrayOutArg(aInstalledExtPacks));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_GET_INSTALLEDEXTPACKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstalledExtPacks(TmpInstalledExtPacks.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_GET_INSTALLEDEXTPACKS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpInstalledExtPacks.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_GET_INSTALLEDEXTPACKS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_GET_INSTALLEDEXTPACKS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInstalledExtPacks=%zu hrc=%Rhrc\n", this, "ExtPackManager::getInstalledExtPacks", !RT_VALID_PTR(aInstalledExtPacks) ? 0 : ComSafeArraySize(*aInstalledExtPacks), hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute1IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute2IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute3IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute4IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute5IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute6IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute7IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::COMGETTER(InternalAndReservedAttribute8IExtPackManager)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackManager methods
//

STDMETHODIMP ExtPackManagerWrap::Find(IN_BSTR aName,
                                      IExtPack **aReturnData)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aReturnData=%p\n", this, "ExtPackManager::find", aName, aReturnData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReturnData);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IExtPack> TmpReturnData(aReturnData);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_FIND_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = find(TmpName.str(),
                       TmpReturnData.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_FIND_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpReturnData.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_FIND_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_FIND_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReturnData=%p hrc=%Rhrc\n", this, "ExtPackManager::find", !RT_VALID_PTR(aReturnData) ? 0 : *aReturnData, hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::OpenExtPackFile(IN_BSTR aPath,
                                                 IExtPackFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls aFile=%p\n", this, "ExtPackManager::openExtPackFile", aPath, 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<IExtPackFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_OPENEXTPACKFILE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = openExtPackFile(TmpPath.str(),
                                  TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_OPENEXTPACKFILE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_OPENEXTPACKFILE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_OPENEXTPACKFILE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "ExtPackManager::openExtPackFile", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::Uninstall(IN_BSTR aName,
                                           BOOL aForcedRemoval,
                                           IN_BSTR aDisplayInfo,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aForcedRemoval=%RTbool aDisplayInfo=%ls aProgress=%p\n", this, "ExtPackManager::uninstall", aName, aForcedRemoval, 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 TmpName(aName);
        
        BSTRInConverter TmpDisplayInfo(aDisplayInfo);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_UNINSTALL_ENTER(this, TmpName.str().c_str(), aForcedRemoval != FALSE, TmpDisplayInfo.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = uninstall(TmpName.str(),
                            aForcedRemoval != FALSE,
                            TmpDisplayInfo.str(),
                            TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_UNINSTALL_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aForcedRemoval != FALSE, TmpDisplayInfo.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_UNINSTALL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aForcedRemoval != FALSE, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_UNINSTALL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aForcedRemoval != FALSE, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "ExtPackManager::uninstall", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::Cleanup()
{
    LogRelFlow(("{%p} %s: enter\n", this, "ExtPackManager::cleanup"));

    // Clear 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_EXTPACKMANAGER_CLEANUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cleanup();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_CLEANUP_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_CLEANUP_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_CLEANUP_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ExtPackManager::cleanup", hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::QueryAllPlugInsForFrontend(IN_BSTR aFrontendName,
                                                            ComSafeArrayOut(BSTR, aPlugInModules))
{
    LogRelFlow(("{%p} %s: enter aFrontendName=%ls aPlugInModules=%p\n", this, "ExtPackManager::queryAllPlugInsForFrontend", aFrontendName, aPlugInModules));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugInModules);


        BSTRInConverter TmpFrontendName(aFrontendName);
        ArrayBSTROutConverter TmpPlugInModules(ComSafeArrayOutArg(aPlugInModules));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_QUERYALLPLUGINSFORFRONTEND_ENTER(this, TmpFrontendName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryAllPlugInsForFrontend(TmpFrontendName.str(),
                                             TmpPlugInModules.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_QUERYALLPLUGINSFORFRONTEND_RETURN(this, hrc, 0 /*normal*/, TmpFrontendName.str().c_str(), (uint32_t)TmpPlugInModules.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_QUERYALLPLUGINSFORFRONTEND_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_EXTPACKMANAGER_QUERYALLPLUGINSFORFRONTEND_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aPlugInModules=%zu hrc=%Rhrc\n", this, "ExtPackManager::queryAllPlugInsForFrontend", !RT_VALID_PTR(aPlugInModules) ? 0 : ComSafeArraySize(*aPlugInModules), hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::IsExtPackUsable(IN_BSTR aName,
                                                 BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aUsable=%p\n", this, "ExtPackManager::isExtPackUsable", aName, 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);


        BSTRInConverter TmpName(aName);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_ISEXTPACKUSABLE_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = isExtPackUsable(TmpName.str(),
                                  aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_ISEXTPACKUSABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), *aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_ISEXTPACKUSABLE_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aUsable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKMANAGER_ISEXTPACKUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPackManager::isExtPackUsable", !RT_VALID_PTR(aUsable) ? 0 : *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackManagerWrap::InternalAndReservedMethod1IExtPackManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::InternalAndReservedMethod2IExtPackManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::InternalAndReservedMethod3IExtPackManager()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackManagerWrap::InternalAndReservedMethod4IExtPackManager()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackManagerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackManagerWrap, IExtPackManager)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackManagerWrap.cpp"


// ##### BEGINFILE "BandwidthGroupWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IBandwidthGroup.
 *
 * 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_BANDWIDTHGROUP

#include "BandwidthGroupWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(BandwidthGroupWrap)

//
// IBandwidthGroup properties
//

STDMETHODIMP BandwidthGroupWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "BandwidthGroup::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_BANDWIDTHGROUP_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_BANDWIDTHGROUP_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_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_BANDWIDTHGROUP_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "BandwidthGroup::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(Type)(BandwidthGroupType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "BandwidthGroup::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_BANDWIDTHGROUP_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_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_BANDWIDTHGROUP_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "BandwidthGroup::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(Reference)(ULONG *aReference)
{
    LogRelFlow(("{%p} %s: enter aReference=%p\n", this, "BandwidthGroup::getReference", aReference));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReference);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_REFERENCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReference(aReference);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_REFERENCE_RETURN(this, hrc, 0 /*normal*/,*aReference);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_REFERENCE_RETURN(this, hrc, 1 /*hrc exception*/,*aReference);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_REFERENCE_RETURN(this, hrc, 9 /*unhandled exception*/,*aReference);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReference=%RU32 hrc=%Rhrc\n", this, "BandwidthGroup::getReference", !RT_VALID_PTR(aReference) ? 0 : *aReference, hrc));
    return hrc;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(MaxBytesPerSec)(LONG64 *aMaxBytesPerSec)
{
    LogRelFlow(("{%p} %s: enter aMaxBytesPerSec=%p\n", this, "BandwidthGroup::getMaxBytesPerSec", 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
    {
        CheckComArgOutPointerValidThrow(aMaxBytesPerSec);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_MAXBYTESPERSEC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxBytesPerSec(aMaxBytesPerSec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_MAXBYTESPERSEC_RETURN(this, hrc, 0 /*normal*/,*aMaxBytesPerSec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_MAXBYTESPERSEC_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxBytesPerSec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_GET_MAXBYTESPERSEC_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxBytesPerSec);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxBytesPerSec=%RI64 hrc=%Rhrc\n", this, "BandwidthGroup::getMaxBytesPerSec", !RT_VALID_PTR(aMaxBytesPerSec) ? 0 : *aMaxBytesPerSec, hrc));
    return hrc;
}

STDMETHODIMP BandwidthGroupWrap::COMSETTER(MaxBytesPerSec)(LONG64 aMaxBytesPerSec)
{
    LogRelFlow(("{%p} %s: enter aMaxBytesPerSec=%RI64\n", this, "BandwidthGroup::setMaxBytesPerSec", 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
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_SET_MAXBYTESPERSEC_ENTER(this, aMaxBytesPerSec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setMaxBytesPerSec(aMaxBytesPerSec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_SET_MAXBYTESPERSEC_RETURN(this, hrc, 0 /*normal*/,aMaxBytesPerSec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_SET_MAXBYTESPERSEC_RETURN(this, hrc, 1 /*hrc exception*/,aMaxBytesPerSec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHGROUP_SET_MAXBYTESPERSEC_RETURN(this, hrc, 9 /*unhandled exception*/,aMaxBytesPerSec);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "BandwidthGroup::setMaxBytesPerSec", hrc));
    return hrc;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(InternalAndReservedAttribute1IBandwidthGroup)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(InternalAndReservedAttribute2IBandwidthGroup)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(InternalAndReservedAttribute3IBandwidthGroup)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthGroupWrap::COMGETTER(InternalAndReservedAttribute4IBandwidthGroup)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IBandwidthGroup methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(BandwidthGroupWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BandwidthGroupWrap, IBandwidthGroup)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "BandwidthGroupWrap.cpp"


// ##### BEGINFILE "GuestDebugControlWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDebugControl.
 *
 * 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_GUESTDEBUGCONTROL

#include "GuestDebugControlWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDebugControlWrap)

//
// IGuestDebugControl properties
//

STDMETHODIMP GuestDebugControlWrap::COMGETTER(DebugProvider)(GuestDebugProvider_T *aDebugProvider)
{
    LogRelFlow(("{%p} %s: enter aDebugProvider=%p\n", this, "GuestDebugControl::getDebugProvider", aDebugProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDebugProvider);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPROVIDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDebugProvider(aDebugProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPROVIDER_RETURN(this, hrc, 0 /*normal*/,*aDebugProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,*aDebugProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDebugProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDebugProvider=%RU32 hrc=%Rhrc\n", this, "GuestDebugControl::getDebugProvider", !RT_VALID_PTR(aDebugProvider) ? 0 : *aDebugProvider, hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMSETTER(DebugProvider)(GuestDebugProvider_T aDebugProvider)
{
    LogRelFlow(("{%p} %s: enter aDebugProvider=%RU32\n", this, "GuestDebugControl::setDebugProvider", aDebugProvider));

    // Clear 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_GUESTDEBUGCONTROL_SET_DEBUGPROVIDER_ENTER(this, aDebugProvider);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDebugProvider(aDebugProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPROVIDER_RETURN(this, hrc, 0 /*normal*/,aDebugProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,aDebugProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,aDebugProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDebugControl::setDebugProvider", hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMGETTER(DebugIoProvider)(GuestDebugIoProvider_T *aDebugIoProvider)
{
    LogRelFlow(("{%p} %s: enter aDebugIoProvider=%p\n", this, "GuestDebugControl::getDebugIoProvider", aDebugIoProvider));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDebugIoProvider);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGIOPROVIDER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDebugIoProvider(aDebugIoProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGIOPROVIDER_RETURN(this, hrc, 0 /*normal*/,*aDebugIoProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGIOPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,*aDebugIoProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGIOPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDebugIoProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDebugIoProvider=%RU32 hrc=%Rhrc\n", this, "GuestDebugControl::getDebugIoProvider", !RT_VALID_PTR(aDebugIoProvider) ? 0 : *aDebugIoProvider, hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMSETTER(DebugIoProvider)(GuestDebugIoProvider_T aDebugIoProvider)
{
    LogRelFlow(("{%p} %s: enter aDebugIoProvider=%RU32\n", this, "GuestDebugControl::setDebugIoProvider", aDebugIoProvider));

    // Clear 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_GUESTDEBUGCONTROL_SET_DEBUGIOPROVIDER_ENTER(this, aDebugIoProvider);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDebugIoProvider(aDebugIoProvider);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGIOPROVIDER_RETURN(this, hrc, 0 /*normal*/,aDebugIoProvider);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGIOPROVIDER_RETURN(this, hrc, 1 /*hrc exception*/,aDebugIoProvider);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGIOPROVIDER_RETURN(this, hrc, 9 /*unhandled exception*/,aDebugIoProvider);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDebugControl::setDebugIoProvider", hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMGETTER(DebugAddress)(BSTR *aDebugAddress)
{
    LogRelFlow(("{%p} %s: enter aDebugAddress=%p\n", this, "GuestDebugControl::getDebugAddress", aDebugAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDebugAddress);
        BSTROutConverter TmpDebugAddress(aDebugAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDebugAddress(TmpDebugAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpDebugAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDebugAddress=%ls hrc=%Rhrc\n", this, "GuestDebugControl::getDebugAddress", !RT_VALID_PTR(aDebugAddress) ? 0 : *aDebugAddress, hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMSETTER(DebugAddress)(IN_BSTR aDebugAddress)
{
    LogRelFlow(("{%p} %s: enter aDebugAddress=%ls\n", this, "GuestDebugControl::setDebugAddress", aDebugAddress));

    // Clear 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 TmpDebugAddress(aDebugAddress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGADDRESS_ENTER(this, TmpDebugAddress.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDebugAddress(TmpDebugAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpDebugAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDebugControl::setDebugAddress", hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMGETTER(DebugPort)(ULONG *aDebugPort)
{
    LogRelFlow(("{%p} %s: enter aDebugPort=%p\n", this, "GuestDebugControl::getDebugPort", aDebugPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDebugPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDebugPort(aDebugPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPORT_RETURN(this, hrc, 0 /*normal*/,*aDebugPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPORT_RETURN(this, hrc, 1 /*hrc exception*/,*aDebugPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_GET_DEBUGPORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aDebugPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDebugPort=%RU32 hrc=%Rhrc\n", this, "GuestDebugControl::getDebugPort", !RT_VALID_PTR(aDebugPort) ? 0 : *aDebugPort, hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMSETTER(DebugPort)(ULONG aDebugPort)
{
    LogRelFlow(("{%p} %s: enter aDebugPort=%RU32\n", this, "GuestDebugControl::setDebugPort", aDebugPort));

    // Clear 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_GUESTDEBUGCONTROL_SET_DEBUGPORT_ENTER(this, aDebugPort);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDebugPort(aDebugPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPORT_RETURN(this, hrc, 0 /*normal*/,aDebugPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPORT_RETURN(this, hrc, 1 /*hrc exception*/,aDebugPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDEBUGCONTROL_SET_DEBUGPORT_RETURN(this, hrc, 9 /*unhandled exception*/,aDebugPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDebugControl::setDebugPort", hrc));
    return hrc;
}

STDMETHODIMP GuestDebugControlWrap::COMGETTER(InternalAndReservedAttribute1IGuestDebugControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDebugControlWrap::COMGETTER(InternalAndReservedAttribute2IGuestDebugControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuestDebugControl methods
//

STDMETHODIMP GuestDebugControlWrap::InternalAndReservedMethod1IGuestDebugControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDebugControlWrap::InternalAndReservedMethod2IGuestDebugControl()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDebugControlWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestDebugControlWrap, IGuestDebugControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDebugControlWrap.cpp"


// ##### BEGINFILE "EventListenerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IEventListener.
 *
 * 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_EVENTLISTENER

#include "EventListenerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(EventListenerWrap)

//
// IEventListener properties
//


//
// IEventListener methods
//

STDMETHODIMP EventListenerWrap::HandleEvent(IEvent *aEvent)
{
    LogRelFlow(("{%p} %s: enter aEvent=%p\n", this, "EventListener::handleEvent", 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<IEvent> TmpEvent(aEvent);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTLISTENER_HANDLEEVENT_ENTER(this, (void *)TmpEvent.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = handleEvent(TmpEvent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTLISTENER_HANDLEEVENT_RETURN(this, hrc, 0 /*normal*/, (void *)TmpEvent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTLISTENER_HANDLEEVENT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EVENTLISTENER_HANDLEEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "EventListener::handleEvent", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(EventListenerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(EventListenerWrap, IEventListener)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "EventListenerWrap.cpp"


// ##### BEGINFILE "ReusableEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IReusableEvent.
 *
 * 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_REUSABLEEVENT

#include "ReusableEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ReusableEventWrap)

//
// IEvent properties
//

STDMETHODIMP ReusableEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "ReusableEvent::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_REUSABLEEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_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_REUSABLEEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "ReusableEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP ReusableEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "ReusableEvent::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_REUSABLEEVENT_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_REUSABLEEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_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_REUSABLEEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "ReusableEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP ReusableEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "ReusableEvent::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_REUSABLEEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_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_REUSABLEEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "ReusableEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IReusableEvent properties
//

STDMETHODIMP ReusableEventWrap::COMGETTER(Generation)(ULONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "ReusableEvent::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_REUSABLEEVENT_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_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_REUSABLEEVENT_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RU32 hrc=%Rhrc\n", this, "ReusableEvent::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP ReusableEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "ReusableEvent::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_REUSABLEEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ReusableEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP ReusableEventWrap::WaitProcessed(LONG aTimeout,
                                              BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "ReusableEvent::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_REUSABLEEVENT_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_REUSABLEEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_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_REUSABLEEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "ReusableEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IReusableEvent methods
//

STDMETHODIMP ReusableEventWrap::Reuse()
{
    LogRelFlow(("{%p} %s: enter\n", this, "ReusableEvent::reuse"));

    // Clear 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_REUSABLEEVENT_REUSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = reuse();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_REUSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_REUSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_REUSABLEEVENT_REUSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "ReusableEvent::reuse", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ReusableEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ReusableEventWrap, IReusableEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ReusableEventWrap.cpp"


// ##### BEGINFILE "GuestSessionEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestSessionEvent.
 *
 * 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_GUESTSESSIONEVENT

#include "GuestSessionEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestSessionEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestSessionEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestSessionEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestSessionEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestSessionEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestSessionEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestSessionEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestSessionEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSessionEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionEventWrap::WaitProcessed(LONG aTimeout,
                                                  BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestSessionEvent::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_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSIONEVENT_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_GUESTSESSIONEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestSessionEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestSessionEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestSessionEventWrap, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestSessionEventWrap.cpp"


// ##### BEGINFILE "GuestProcessIOEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestProcessIOEvent.
 *
 * 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_GUESTPROCESSIOEVENT

#include "GuestProcessIOEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestProcessIOEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestProcessIOEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestProcessIOEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestProcessIOEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestProcessIOEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

//
// IGuestProcessEvent properties
//

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Process)(IGuestProcess **aProcess)
{
    LogRelFlow(("{%p} %s: enter aProcess=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_PROCESS_RETURN(this, hrc, 0 /*normal*/,(void *)TmpProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_PROCESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcess=%p hrc=%Rhrc\n", this, "GuestProcessIOEvent::getProcess", !RT_VALID_PTR(aProcess) ? 0 : *aProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Pid)(ULONG *aPid)
{
    LogRelFlow(("{%p} %s: enter aPid=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPid(aPid);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPid);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPid);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPid=%RU32 hrc=%Rhrc\n", this, "GuestProcessIOEvent::getPid", !RT_VALID_PTR(aPid) ? 0 : *aPid, hrc));
    return hrc;
}

//
// IGuestProcessIOEvent properties
//

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Handle)(ULONG *aHandle)
{
    LogRelFlow(("{%p} %s: enter aHandle=%p\n", this, "GuestProcessIOEvent::getHandle", aHandle));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHandle);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_HANDLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHandle(aHandle);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_HANDLE_RETURN(this, hrc, 0 /*normal*/,*aHandle);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_HANDLE_RETURN(this, hrc, 1 /*hrc exception*/,*aHandle);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_HANDLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHandle);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHandle=%RU32 hrc=%Rhrc\n", this, "GuestProcessIOEvent::getHandle", !RT_VALID_PTR(aHandle) ? 0 : *aHandle, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessIOEventWrap::COMGETTER(Processed)(ULONG *aProcessed)
{
    LogRelFlow(("{%p} %s: enter aProcessed=%p\n", this, "GuestProcessIOEvent::getProcessed", aProcessed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProcessed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_PROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessed(aProcessed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_PROCESSED_RETURN(this, hrc, 0 /*normal*/,*aProcessed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_PROCESSED_RETURN(this, hrc, 1 /*hrc exception*/,*aProcessed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_GET_PROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/,*aProcessed);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcessed=%RU32 hrc=%Rhrc\n", this, "GuestProcessIOEvent::getProcessed", !RT_VALID_PTR(aProcessed) ? 0 : *aProcessed, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestProcessIOEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestProcessIOEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestProcessIOEventWrap::WaitProcessed(LONG aTimeout,
                                                    BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestProcessIOEvent::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_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESSIOEVENT_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_GUESTPROCESSIOEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestProcessIOEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

//
// IGuestProcessEvent methods
//

//
// IGuestProcessIOEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestProcessIOEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS4_CI(GuestProcessIOEventWrap, IGuestProcessIOEvent, IGuestProcessEvent, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestProcessIOEventWrap.cpp"


// ##### BEGINFILE "GuestFileIOEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFileIOEvent.
 *
 * 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_GUESTFILEIOEVENT

#include "GuestFileIOEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFileIOEventWrap)

//
// IEvent properties
//

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestFileIOEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "GuestFileIOEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "GuestFileIOEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IGuestSessionEvent properties
//

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Session)(IGuestSession **aSession)
{
    LogRelFlow(("{%p} %s: enter aSession=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_SESSION_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSession.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_SESSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSession=%p hrc=%Rhrc\n", this, "GuestFileIOEvent::getSession", !RT_VALID_PTR(aSession) ? 0 : *aSession, hrc));
    return hrc;
}

//
// IGuestFileEvent properties
//

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(File)(IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s: enter aFile=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_FILE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_FILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFile=%p hrc=%Rhrc\n", this, "GuestFileIOEvent::getFile", !RT_VALID_PTR(aFile) ? 0 : *aFile, hrc));
    return hrc;
}

//
// IGuestFileIOEvent properties
//

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Offset)(LONG64 *aOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_GET_OFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOffset(aOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_OFFSET_RETURN(this, hrc, 0 /*normal*/,*aOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_GET_OFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOffset=%RI64 hrc=%Rhrc\n", this, "GuestFileIOEvent::getOffset", !RT_VALID_PTR(aOffset) ? 0 : *aOffset, hrc));
    return hrc;
}

STDMETHODIMP GuestFileIOEventWrap::COMGETTER(Processed)(ULONG *aProcessed)
{
    LogRelFlow(("{%p} %s: enter aProcessed=%p\n", this, "GuestFileIOEvent::getProcessed", aProcessed));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProcessed);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_PROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcessed(aProcessed);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_PROCESSED_RETURN(this, hrc, 0 /*normal*/,*aProcessed);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_PROCESSED_RETURN(this, hrc, 1 /*hrc exception*/,*aProcessed);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_GET_PROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/,*aProcessed);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcessed=%RU32 hrc=%Rhrc\n", this, "GuestFileIOEvent::getProcessed", !RT_VALID_PTR(aProcessed) ? 0 : *aProcessed, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP GuestFileIOEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFileIOEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP GuestFileIOEventWrap::WaitProcessed(LONG aTimeout,
                                                 BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "GuestFileIOEvent::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_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILEIOEVENT_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_GUESTFILEIOEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "GuestFileIOEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IGuestSessionEvent methods
//

//
// IGuestFileEvent methods
//

//
// IGuestFileIOEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFileIOEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS4_CI(GuestFileIOEventWrap, IGuestFileIOEvent, IGuestFileEvent, IGuestSessionEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFileIOEventWrap.cpp"


// ##### BEGINFILE "UpdateAgentEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IUpdateAgentEvent.
 *
 * 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_UPDATEAGENTEVENT

#include "UpdateAgentEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(UpdateAgentEventWrap)

//
// IEvent properties
//

STDMETHODIMP UpdateAgentEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "UpdateAgentEvent::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_UPDATEAGENTEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "UpdateAgentEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "UpdateAgentEvent::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_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "UpdateAgentEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "UpdateAgentEvent::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_UPDATEAGENTEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "UpdateAgentEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// IUpdateAgentEvent properties
//

STDMETHODIMP UpdateAgentEventWrap::COMGETTER(Agent)(IUpdateAgent **aAgent)
{
    LogRelFlow(("{%p} %s: enter aAgent=%p\n", this, "UpdateAgentEvent::getAgent", aAgent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAgent);
        ComTypeOutConverter<IUpdateAgent> TmpAgent(aAgent);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_AGENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAgent(TmpAgent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_AGENT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpAgent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_AGENT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_GET_AGENT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAgent=%p hrc=%Rhrc\n", this, "UpdateAgentEvent::getAgent", !RT_VALID_PTR(aAgent) ? 0 : *aAgent, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP UpdateAgentEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "UpdateAgentEvent::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_UPDATEAGENTEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "UpdateAgentEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP UpdateAgentEventWrap::WaitProcessed(LONG aTimeout,
                                                 BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "UpdateAgentEvent::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_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_UPDATEAGENTEVENT_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_UPDATEAGENTEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "UpdateAgentEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// IUpdateAgentEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(UpdateAgentEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(UpdateAgentEventWrap, IUpdateAgentEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "UpdateAgentEventWrap.cpp"


// ##### BEGINFILE "BooleanFormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IBooleanFormValue.
 *
 * 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_BOOLEANFORMVALUE

#include "BooleanFormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(BooleanFormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "BooleanFormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "BooleanFormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "BooleanFormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "BooleanFormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "BooleanFormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "BooleanFormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "BooleanFormValue::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_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_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_BOOLEANFORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "BooleanFormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IBooleanFormValue properties
//

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute1IBooleanFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute2IBooleanFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute3IBooleanFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::COMGETTER(InternalAndReservedAttribute4IBooleanFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IBooleanFormValue methods
//

STDMETHODIMP BooleanFormValueWrap::GetSelected(BOOL *aSelected)
{
    LogRelFlow(("{%p} %s: enter aSelected=%p\n", this, "BooleanFormValue::getSelected", aSelected));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSelected);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GETSELECTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSelected(aSelected);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GETSELECTED_RETURN(this, hrc, 0 /*normal*/, *aSelected != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GETSELECTED_RETURN(this, hrc, 1 /*hrc exception*/, *aSelected != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_GETSELECTED_RETURN(this, hrc, 9 /*unhandled exception*/, *aSelected != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSelected=%RTbool hrc=%Rhrc\n", this, "BooleanFormValue::getSelected", !RT_VALID_PTR(aSelected) ? 0 : *aSelected, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::SetSelected(BOOL aSelected,
                                               IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aSelected=%RTbool aProgress=%p\n", this, "BooleanFormValue::setSelected", aSelected, 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_BOOLEANFORMVALUE_SETSELECTED_ENTER(this, aSelected != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSelected(aSelected != FALSE,
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_SETSELECTED_RETURN(this, hrc, 0 /*normal*/, aSelected != FALSE, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_SETSELECTED_RETURN(this, hrc, 1 /*hrc exception*/, aSelected != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BOOLEANFORMVALUE_SETSELECTED_RETURN(this, hrc, 9 /*unhandled exception*/, aSelected != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "BooleanFormValue::setSelected", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod1IBooleanFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod2IBooleanFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod3IBooleanFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP BooleanFormValueWrap::InternalAndReservedMethod4IBooleanFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(BooleanFormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(BooleanFormValueWrap, IBooleanFormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "BooleanFormValueWrap.cpp"


// ##### BEGINFILE "RangedInteger64FormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IRangedInteger64FormValue.
 *
 * 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_RANGEDINTEGER64FORMVALUE

#include "RangedInteger64FormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(RangedInteger64FormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "RangedInteger64FormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "RangedInteger64FormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "RangedInteger64FormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "RangedInteger64FormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "RangedInteger64FormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "RangedInteger64FormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "RangedInteger64FormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IRangedInteger64FormValue properties
//

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Suffix)(BSTR *aSuffix)
{
    LogRelFlow(("{%p} %s: enter aSuffix=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_SUFFIX_RETURN(this, hrc, 0 /*normal*/,TmpSuffix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_SUFFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSuffix=%ls hrc=%Rhrc\n", this, "RangedInteger64FormValue::getSuffix", !RT_VALID_PTR(aSuffix) ? 0 : *aSuffix, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Minimum)(LONG64 *aMinimum)
{
    LogRelFlow(("{%p} %s: enter aMinimum=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_MINIMUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinimum(aMinimum);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_MINIMUM_RETURN(this, hrc, 0 /*normal*/,*aMinimum);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_MINIMUM_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinimum);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinimum=%RI64 hrc=%Rhrc\n", this, "RangedInteger64FormValue::getMinimum", !RT_VALID_PTR(aMinimum) ? 0 : *aMinimum, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(Maximum)(LONG64 *aMaximum)
{
    LogRelFlow(("{%p} %s: enter aMaximum=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GET_MAXIMUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaximum(aMaximum);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GET_MAXIMUM_RETURN(this, hrc, 0 /*normal*/,*aMaximum);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_GET_MAXIMUM_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaximum);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaximum=%RI64 hrc=%Rhrc\n", this, "RangedInteger64FormValue::getMaximum", !RT_VALID_PTR(aMaximum) ? 0 : *aMaximum, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute1IRangedInteger64FormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute2IRangedInteger64FormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute3IRangedInteger64FormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::COMGETTER(InternalAndReservedAttribute4IRangedInteger64FormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IRangedInteger64FormValue methods
//

STDMETHODIMP RangedInteger64FormValueWrap::GetInteger(LONG64 *aValue)
{
    LogRelFlow(("{%p} %s: enter aValue=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_GETINTEGER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInteger(aValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GETINTEGER_RETURN(this, hrc, 0 /*normal*/, *aValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GETINTEGER_RETURN(this, hrc, 1 /*hrc exception*/, *aValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_GETINTEGER_RETURN(this, hrc, 9 /*unhandled exception*/, *aValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%RI64 hrc=%Rhrc\n", this, "RangedInteger64FormValue::getInteger", !RT_VALID_PTR(aValue) ? 0 : *aValue, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::SetInteger(LONG64 aValue,
                                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aValue=%RI64 aProgress=%p\n", this, "RangedInteger64FormValue::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_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_SETINTEGER_RETURN(this, hrc, 0 /*normal*/, aValue, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RANGEDINTEGER64FORMVALUE_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_RANGEDINTEGER64FORMVALUE_SETINTEGER_RETURN(this, hrc, 9 /*unhandled exception*/, aValue, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "RangedInteger64FormValue::setInteger", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod1IRangedInteger64FormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod2IRangedInteger64FormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod3IRangedInteger64FormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP RangedInteger64FormValueWrap::InternalAndReservedMethod4IRangedInteger64FormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(RangedInteger64FormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RangedInteger64FormValueWrap, IRangedInteger64FormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "RangedInteger64FormValueWrap.cpp"


// ##### BEGINFILE "ChoiceFormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IChoiceFormValue.
 *
 * 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_CHOICEFORMVALUE

#include "ChoiceFormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ChoiceFormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "ChoiceFormValue::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "ChoiceFormValue::getGeneration", !RT_VALID_PTR(aGeneration) ? 0 : *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "ChoiceFormValue::getEnabled", !RT_VALID_PTR(aEnabled) ? 0 : *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "ChoiceFormValue::getVisible", !RT_VALID_PTR(aVisible) ? 0 : *aVisible, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "ChoiceFormValue::getLabel", !RT_VALID_PTR(aLabel) ? 0 : *aLabel, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ChoiceFormValue::getDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "ChoiceFormValue::getHelp", !RT_VALID_PTR(aHelp) ? 0 : *aHelp, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IChoiceFormValue properties
//

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(Values)(ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aValues=%p\n", this, "ChoiceFormValue::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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_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_CHOICEFORMVALUE_GET_VALUES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%zu hrc=%Rhrc\n", this, "ChoiceFormValue::getValues", !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute1IChoiceFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute2IChoiceFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute3IChoiceFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::COMGETTER(InternalAndReservedAttribute4IChoiceFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IChoiceFormValue methods
//

STDMETHODIMP ChoiceFormValueWrap::GetSelectedIndex(LONG *aIndex)
{
    LogRelFlow(("{%p} %s: enter aIndex=%p\n", this, "ChoiceFormValue::getSelectedIndex", aIndex));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIndex);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GETSELECTEDINDEX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSelectedIndex(aIndex);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GETSELECTEDINDEX_RETURN(this, hrc, 0 /*normal*/, *aIndex);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GETSELECTEDINDEX_RETURN(this, hrc, 1 /*hrc exception*/, *aIndex);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_GETSELECTEDINDEX_RETURN(this, hrc, 9 /*unhandled exception*/, *aIndex);
#endif
    }

    LogRelFlow(("{%p} %s: leave aIndex=%RI32 hrc=%Rhrc\n", this, "ChoiceFormValue::getSelectedIndex", !RT_VALID_PTR(aIndex) ? 0 : *aIndex, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::SetSelectedIndex(LONG aIndex,
                                                   IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aIndex=%RI32 aProgress=%p\n", this, "ChoiceFormValue::setSelectedIndex", aIndex, 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_CHOICEFORMVALUE_SETSELECTEDINDEX_ENTER(this, aIndex);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSelectedIndex(aIndex,
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_SETSELECTEDINDEX_RETURN(this, hrc, 0 /*normal*/, aIndex, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_SETSELECTEDINDEX_RETURN(this, hrc, 1 /*hrc exception*/, aIndex, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CHOICEFORMVALUE_SETSELECTEDINDEX_RETURN(this, hrc, 9 /*unhandled exception*/, aIndex, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "ChoiceFormValue::setSelectedIndex", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod1IChoiceFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod2IChoiceFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod3IChoiceFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP ChoiceFormValueWrap::InternalAndReservedMethod4IChoiceFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ChoiceFormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ChoiceFormValueWrap, IChoiceFormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ChoiceFormValueWrap.cpp"


// ##### BEGINFILE "VirtualSystemDescriptionFormWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVirtualSystemDescriptionForm.
 *
 * 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_VIRTUALSYSTEMDESCRIPTIONFORM

#include "VirtualSystemDescriptionFormWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescriptionFormWrap)

//
// IForm properties
//

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(Values)(ComSafeArrayOut(IFormValue *, aValues))
{
    LogRelFlow(("{%p} %s: enter aValues=%p\n", this, "VirtualSystemDescriptionForm::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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_GET_VALUES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescriptionForm::getValues", !RT_VALID_PTR(aValues) ? 0 : ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute1IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute2IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute3IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute4IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IVirtualSystemDescriptionForm properties
//

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescriptionForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescriptionForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescriptionForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescriptionForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IForm methods
//

STDMETHODIMP VirtualSystemDescriptionFormWrap::GetFieldGroup(IN_BSTR aField,
                                                             ComSafeArrayOut(BSTR, aGroup))
{
    LogRelFlow(("{%p} %s: enter aField=%ls aGroup=%p\n", this, "VirtualSystemDescriptionForm::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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_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_VIRTUALSYSTEMDESCRIPTIONFORM_GETFIELDGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGroup=%zu hrc=%Rhrc\n", this, "VirtualSystemDescriptionForm::getFieldGroup", !RT_VALID_PTR(aGroup) ? 0 : ComSafeArraySize(*aGroup), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::Apply(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "VirtualSystemDescriptionForm::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_VIRTUALSYSTEMDESCRIPTIONFORM_APPLY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = apply(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_APPLY_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_APPLY_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_APPLY_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "VirtualSystemDescriptionForm::apply", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod1IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod2IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod3IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod4IForm()
{
    return E_NOTIMPL;
}

//
// IVirtualSystemDescriptionForm methods
//

STDMETHODIMP VirtualSystemDescriptionFormWrap::GetVirtualSystemDescription(IVirtualSystemDescription **aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "VirtualSystemDescriptionForm::getVirtualSystemDescription", 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);


        ComTypeOutConverter<IVirtualSystemDescription> TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_GETVIRTUALSYSTEMDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVirtualSystemDescription(TmpDescription.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_GETVIRTUALSYSTEMDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_GETVIRTUALSYSTEMDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTIONFORM_GETVIRTUALSYSTEMDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDescription=%p hrc=%Rhrc\n", this, "VirtualSystemDescriptionForm::getVirtualSystemDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod1IVirtualSystemDescriptionForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod2IVirtualSystemDescriptionForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod3IVirtualSystemDescriptionForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionFormWrap::InternalAndReservedMethod4IVirtualSystemDescriptionForm()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VirtualSystemDescriptionFormWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(VirtualSystemDescriptionFormWrap, IVirtualSystemDescriptionForm, IForm)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VirtualSystemDescriptionFormWrap.cpp"


// ##### BEGINFILE "CloudNetworkEnvironmentInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudNetworkEnvironmentInfo.
 *
 * 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_CLOUDNETWORKENVIRONMENTINFO

#include "CloudNetworkEnvironmentInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudNetworkEnvironmentInfoWrap)

//
// ICloudNetworkEnvironmentInfo properties
//

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(TunnelNetworkId)(BSTR *aTunnelNetworkId)
{
    LogRelFlow(("{%p} %s: enter aTunnelNetworkId=%p\n", this, "CloudNetworkEnvironmentInfo::getTunnelNetworkId", aTunnelNetworkId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTunnelNetworkId);
        BSTROutConverter TmpTunnelNetworkId(aTunnelNetworkId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKENVIRONMENTINFO_GET_TUNNELNETWORKID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTunnelNetworkId(TmpTunnelNetworkId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKENVIRONMENTINFO_GET_TUNNELNETWORKID_RETURN(this, hrc, 0 /*normal*/,TmpTunnelNetworkId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKENVIRONMENTINFO_GET_TUNNELNETWORKID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKENVIRONMENTINFO_GET_TUNNELNETWORKID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTunnelNetworkId=%ls hrc=%Rhrc\n", this, "CloudNetworkEnvironmentInfo::getTunnelNetworkId", !RT_VALID_PTR(aTunnelNetworkId) ? 0 : *aTunnelNetworkId, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute1ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute2ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute3ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute4ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute5ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute6ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkEnvironmentInfoWrap::COMGETTER(InternalAndReservedAttribute7ICloudNetworkEnvironmentInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudNetworkEnvironmentInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudNetworkEnvironmentInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudNetworkEnvironmentInfoWrap, ICloudNetworkEnvironmentInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudNetworkEnvironmentInfoWrap.cpp"


// ##### BEGINFILE "CloudClientWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudClient.
 *
 * 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_CLOUDCLIENT

#include "CloudClientWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudClientWrap)

//
// ICloudClient properties
//

STDMETHODIMP CloudClientWrap::COMGETTER(CloudMachineList)(ComSafeArrayOut(ICloudMachine *, aCloudMachineList))
{
    LogRelFlow(("{%p} %s: enter aCloudMachineList=%p\n", this, "CloudClient::getCloudMachineList", aCloudMachineList));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudMachineList);
        ArrayComTypeOutConverter<ICloudMachine> TmpCloudMachineList(ComSafeArrayOutArg(aCloudMachineList));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINELIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudMachineList(TmpCloudMachineList.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINELIST_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpCloudMachineList.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINELIST_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINELIST_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudMachineList=%zu hrc=%Rhrc\n", this, "CloudClient::getCloudMachineList", !RT_VALID_PTR(aCloudMachineList) ? 0 : ComSafeArraySize(*aCloudMachineList), hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::COMGETTER(CloudMachineStubList)(ComSafeArrayOut(ICloudMachine *, aCloudMachineStubList))
{
    LogRelFlow(("{%p} %s: enter aCloudMachineStubList=%p\n", this, "CloudClient::getCloudMachineStubList", aCloudMachineStubList));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCloudMachineStubList);
        ArrayComTypeOutConverter<ICloudMachine> TmpCloudMachineStubList(ComSafeArrayOutArg(aCloudMachineStubList));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINESTUBLIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudMachineStubList(TmpCloudMachineStubList.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINESTUBLIST_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpCloudMachineStubList.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINESTUBLIST_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GET_CLOUDMACHINESTUBLIST_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCloudMachineStubList=%zu hrc=%Rhrc\n", this, "CloudClient::getCloudMachineStubList", !RT_VALID_PTR(aCloudMachineStubList) ? 0 : ComSafeArraySize(*aCloudMachineStubList), hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute1ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute2ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute3ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute4ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute5ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute6ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute7ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::COMGETTER(InternalAndReservedAttribute8ICloudClient)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudClient methods
//

STDMETHODIMP CloudClientWrap::GetExportDescriptionForm(IVirtualSystemDescription *aDescription,
                                                       IVirtualSystemDescriptionForm **aForm,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aForm=%p aProgress=%p\n", this, "CloudClient::getExportDescriptionForm", aDescription, 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);


        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IVirtualSystemDescriptionForm> TmpForm(aForm);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETEXPORTDESCRIPTIONFORM_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExportDescriptionForm(TmpDescription.ptr(),
                                           TmpForm.ptr(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETEXPORTDESCRIPTIONFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpForm.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETEXPORTDESCRIPTIONFORM_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_CLOUDCLIENT_GETEXPORTDESCRIPTIONFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForm=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getExportDescriptionForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ExportVM(IVirtualSystemDescription *aDescription,
                                       IProgress *aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aProgress=%p\n", this, "CloudClient::exportVM", aDescription, 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<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeInConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTVM_ENTER(this, (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = exportVM(TmpDescription.ptr(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTVM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTVM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTVM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudClient::exportVM", hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetLaunchDescriptionForm(IVirtualSystemDescription *aDescription,
                                                       IVirtualSystemDescriptionForm **aForm,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aForm=%p aProgress=%p\n", this, "CloudClient::getLaunchDescriptionForm", aDescription, 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);


        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IVirtualSystemDescriptionForm> TmpForm(aForm);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETLAUNCHDESCRIPTIONFORM_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLaunchDescriptionForm(TmpDescription.ptr(),
                                           TmpForm.ptr(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETLAUNCHDESCRIPTIONFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpForm.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETLAUNCHDESCRIPTIONFORM_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_CLOUDCLIENT_GETLAUNCHDESCRIPTIONFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForm=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getLaunchDescriptionForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::LaunchVM(IVirtualSystemDescription *aDescription,
                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aProgress=%p\n", this, "CloudClient::launchVM", aDescription, 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<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LAUNCHVM_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = launchVM(TmpDescription.ptr(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LAUNCHVM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LAUNCHVM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LAUNCHVM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::launchVM", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetImportDescriptionForm(IVirtualSystemDescription *aDescription,
                                                       IVirtualSystemDescriptionForm **aForm,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aForm=%p aProgress=%p\n", this, "CloudClient::getImportDescriptionForm", aDescription, 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);


        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IVirtualSystemDescriptionForm> TmpForm(aForm);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMPORTDESCRIPTIONFORM_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getImportDescriptionForm(TmpDescription.ptr(),
                                           TmpForm.ptr(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMPORTDESCRIPTIONFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpForm.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMPORTDESCRIPTIONFORM_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_CLOUDCLIENT_GETIMPORTDESCRIPTIONFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForm=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getImportDescriptionForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ImportInstance(IVirtualSystemDescription *aDescription,
                                             IProgress *aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aProgress=%p\n", this, "CloudClient::importInstance", aDescription, 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<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeInConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTINSTANCE_ENTER(this, (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = importInstance(TmpDescription.ptr(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTINSTANCE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudClient::importInstance", hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetCloudMachine(IN_BSTR aId,
                                              ICloudMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aId=%ls aMachine=%p\n", this, "CloudClient::getCloudMachine", aId, 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);


        UuidInConverter TmpId(aId);
        ComTypeOutConverter<ICloudMachine> TmpMachine(aMachine);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETCLOUDMACHINE_ENTER(this, TmpId.uuid().toStringCurly().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCloudMachine(TmpId.uuid(),
                                  TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETCLOUDMACHINE_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETCLOUDMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETCLOUDMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMachine=%p hrc=%Rhrc\n", this, "CloudClient::getCloudMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ReadCloudMachineList(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudClient::readCloudMachineList", 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_CLOUDCLIENT_READCLOUDMACHINELIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readCloudMachineList(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINELIST_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINELIST_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINELIST_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::readCloudMachineList", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ReadCloudMachineStubList(IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aProgress=%p\n", this, "CloudClient::readCloudMachineStubList", 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_CLOUDCLIENT_READCLOUDMACHINESTUBLIST_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = readCloudMachineStubList(TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINESTUBLIST_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINESTUBLIST_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_READCLOUDMACHINESTUBLIST_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::readCloudMachineStubList", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::AddCloudMachine(IN_BSTR aInstanceId,
                                              ICloudMachine **aMachine,
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aInstanceId=%ls aMachine=%p aProgress=%p\n", this, "CloudClient::addCloudMachine", aInstanceId, aMachine, 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(aMachine);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpInstanceId(aInstanceId);
        ComTypeOutConverter<ICloudMachine> TmpMachine(aMachine);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_ADDCLOUDMACHINE_ENTER(this, TmpInstanceId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = addCloudMachine(TmpInstanceId.str(),
                                  TmpMachine.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_ADDCLOUDMACHINE_RETURN(this, hrc, 0 /*normal*/, TmpInstanceId.str().c_str(), (void *)TmpMachine.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_ADDCLOUDMACHINE_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_CLOUDCLIENT_ADDCLOUDMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::addCloudMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::CreateCloudMachine(IVirtualSystemDescription *aDescription,
                                                 ICloudMachine **aMachine,
                                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aMachine=%p aProgress=%p\n", this, "CloudClient::createCloudMachine", aDescription, aMachine, 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(aMachine);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<ICloudMachine> TmpMachine(aMachine);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATECLOUDMACHINE_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createCloudMachine(TmpDescription.ptr(),
                                     TmpMachine.ptr(),
                                     TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATECLOUDMACHINE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpMachine.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATECLOUDMACHINE_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_CLOUDCLIENT_CREATECLOUDMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::createCloudMachine", !RT_VALID_PTR(aMachine) ? 0 : *aMachine, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListInstances(ComSafeArrayIn(CloudMachineState_T, aMachineState),
                                            IStringArray **aReturnNames,
                                            IStringArray **aReturnIds,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aMachineState=%zu aReturnNames=%p aReturnIds=%p aProgress=%p\n", this, "CloudClient::listInstances", aMachineState, aReturnNames, aReturnIds, 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(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayInConverter<CloudMachineState_T> TmpMachineState(ComSafeArrayInArg(aMachineState));
        ComTypeOutConverter<IStringArray> TmpReturnNames(aReturnNames);
        ComTypeOutConverter<IStringArray> TmpReturnIds(aReturnIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTINSTANCES_ENTER(this, (uint32_t)TmpMachineState.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listInstances(TmpMachineState.array(),
                                TmpReturnNames.ptr(),
                                TmpReturnIds.ptr(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTINSTANCES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpMachineState.array().size(), NULL /*for now*/, (void *)TmpReturnNames.ptr(), (void *)TmpReturnIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTINSTANCES_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_CLOUDCLIENT_LISTINSTANCES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%p *aReturnIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listInstances", !RT_VALID_PTR(aReturnNames) ? 0 : *aReturnNames, !RT_VALID_PTR(aReturnIds) ? 0 : *aReturnIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListSourceInstances(IStringArray **aReturnNames,
                                                  IStringArray **aReturnIds,
                                                  IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aReturnNames=%p aReturnIds=%p aProgress=%p\n", this, "CloudClient::listSourceInstances", aReturnNames, aReturnIds, 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(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IStringArray> TmpReturnNames(aReturnNames);
        ComTypeOutConverter<IStringArray> TmpReturnIds(aReturnIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEINSTANCES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listSourceInstances(TmpReturnNames.ptr(),
                                      TmpReturnIds.ptr(),
                                      TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEINSTANCES_RETURN(this, hrc, 0 /*normal*/, (void *)TmpReturnNames.ptr(), (void *)TmpReturnIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEINSTANCES_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_CLOUDCLIENT_LISTSOURCEINSTANCES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%p *aReturnIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listSourceInstances", !RT_VALID_PTR(aReturnNames) ? 0 : *aReturnNames, !RT_VALID_PTR(aReturnIds) ? 0 : *aReturnIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListImages(ComSafeArrayIn(CloudImageState_T, aImageState),
                                         IStringArray **aReturnNames,
                                         IStringArray **aReturnIds,
                                         IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aImageState=%zu aReturnNames=%p aReturnIds=%p aProgress=%p\n", this, "CloudClient::listImages", aImageState, aReturnNames, aReturnIds, 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(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayInConverter<CloudImageState_T> TmpImageState(ComSafeArrayInArg(aImageState));
        ComTypeOutConverter<IStringArray> TmpReturnNames(aReturnNames);
        ComTypeOutConverter<IStringArray> TmpReturnIds(aReturnIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTIMAGES_ENTER(this, (uint32_t)TmpImageState.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listImages(TmpImageState.array(),
                             TmpReturnNames.ptr(),
                             TmpReturnIds.ptr(),
                             TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTIMAGES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpImageState.array().size(), NULL /*for now*/, (void *)TmpReturnNames.ptr(), (void *)TmpReturnIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTIMAGES_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_CLOUDCLIENT_LISTIMAGES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%p *aReturnIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listImages", !RT_VALID_PTR(aReturnNames) ? 0 : *aReturnNames, !RT_VALID_PTR(aReturnIds) ? 0 : *aReturnIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListBootVolumes(IStringArray **aReturnNames,
                                              IStringArray **aReturnIds,
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aReturnNames=%p aReturnIds=%p aProgress=%p\n", this, "CloudClient::listBootVolumes", aReturnNames, aReturnIds, 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(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IStringArray> TmpReturnNames(aReturnNames);
        ComTypeOutConverter<IStringArray> TmpReturnIds(aReturnIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTBOOTVOLUMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listBootVolumes(TmpReturnNames.ptr(),
                                  TmpReturnIds.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTBOOTVOLUMES_RETURN(this, hrc, 0 /*normal*/, (void *)TmpReturnNames.ptr(), (void *)TmpReturnIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTBOOTVOLUMES_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_CLOUDCLIENT_LISTBOOTVOLUMES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%p *aReturnIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listBootVolumes", !RT_VALID_PTR(aReturnNames) ? 0 : *aReturnNames, !RT_VALID_PTR(aReturnIds) ? 0 : *aReturnIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListSourceBootVolumes(IStringArray **aReturnNames,
                                                    IStringArray **aReturnIds,
                                                    IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aReturnNames=%p aReturnIds=%p aProgress=%p\n", this, "CloudClient::listSourceBootVolumes", aReturnNames, aReturnIds, 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(aReturnNames);
        CheckComArgOutPointerValidThrow(aReturnIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IStringArray> TmpReturnNames(aReturnNames);
        ComTypeOutConverter<IStringArray> TmpReturnIds(aReturnIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEBOOTVOLUMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listSourceBootVolumes(TmpReturnNames.ptr(),
                                        TmpReturnIds.ptr(),
                                        TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEBOOTVOLUMES_RETURN(this, hrc, 0 /*normal*/, (void *)TmpReturnNames.ptr(), (void *)TmpReturnIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTSOURCEBOOTVOLUMES_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_CLOUDCLIENT_LISTSOURCEBOOTVOLUMES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnNames=%p *aReturnIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listSourceBootVolumes", !RT_VALID_PTR(aReturnNames) ? 0 : *aReturnNames, !RT_VALID_PTR(aReturnIds) ? 0 : *aReturnIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ListVnicAttachments(ComSafeArrayIn(IN_BSTR, aParameters),
                                                  IStringArray **aReturnVnicAttachmentIds,
                                                  IStringArray **aReturnVnicIds,
                                                  IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aParameters=%zu aReturnVnicAttachmentIds=%p aReturnVnicIds=%p aProgress=%p\n", this, "CloudClient::listVnicAttachments", aParameters, aReturnVnicAttachmentIds, aReturnVnicIds, 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(aReturnVnicAttachmentIds);
        CheckComArgOutPointerValidThrow(aReturnVnicIds);
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpParameters(ComSafeArrayInArg(aParameters));
        ComTypeOutConverter<IStringArray> TmpReturnVnicAttachmentIds(aReturnVnicAttachmentIds);
        ComTypeOutConverter<IStringArray> TmpReturnVnicIds(aReturnVnicIds);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTVNICATTACHMENTS_ENTER(this, (uint32_t)TmpParameters.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = listVnicAttachments(TmpParameters.array(),
                                      TmpReturnVnicAttachmentIds.ptr(),
                                      TmpReturnVnicIds.ptr(),
                                      TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTVNICATTACHMENTS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpParameters.array().size(), NULL /*for now*/, (void *)TmpReturnVnicAttachmentIds.ptr(), (void *)TmpReturnVnicIds.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_LISTVNICATTACHMENTS_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_CLOUDCLIENT_LISTVNICATTACHMENTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReturnVnicAttachmentIds=%p *aReturnVnicIds=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::listVnicAttachments", !RT_VALID_PTR(aReturnVnicAttachmentIds) ? 0 : *aReturnVnicAttachmentIds, !RT_VALID_PTR(aReturnVnicIds) ? 0 : *aReturnVnicIds, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetInstanceInfo(IN_BSTR aUid,
                                              IVirtualSystemDescription *aDescription,
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aDescription=%p aProgress=%p\n", this, "CloudClient::getInstanceInfo", aUid, aDescription, 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 TmpUid(aUid);
        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETINSTANCEINFO_ENTER(this, TmpUid.str().c_str(), (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstanceInfo(TmpUid.str(),
                                  TmpDescription.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETINSTANCEINFO_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpDescription.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETINSTANCEINFO_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_CLOUDCLIENT_GETINSTANCEINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getInstanceInfo", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::StartInstance(IN_BSTR aUid,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aProgress=%p\n", this, "CloudClient::startInstance", aUid, 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 TmpUid(aUid);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTINSTANCE_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = startInstance(TmpUid.str(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTINSTANCE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::startInstance", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::PauseInstance(IN_BSTR aUid,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aProgress=%p\n", this, "CloudClient::pauseInstance", aUid, 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 TmpUid(aUid);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_PAUSEINSTANCE_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = pauseInstance(TmpUid.str(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_PAUSEINSTANCE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_PAUSEINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_PAUSEINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::pauseInstance", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::TerminateInstance(IN_BSTR aUid,
                                                IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aProgress=%p\n", this, "CloudClient::terminateInstance", aUid, 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 TmpUid(aUid);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_TERMINATEINSTANCE_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = terminateInstance(TmpUid.str(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_TERMINATEINSTANCE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_TERMINATEINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_TERMINATEINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::terminateInstance", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ResetInstance(IN_BSTR aUid,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aProgress=%p\n", this, "CloudClient::resetInstance", aUid, 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 TmpUid(aUid);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_RESETINSTANCE_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = resetInstance(TmpUid.str(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_RESETINSTANCE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_RESETINSTANCE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_RESETINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::resetInstance", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::CloneInstance(IN_BSTR aUid,
                                            IN_BSTR aNewName,
                                            ICloudMachine **aClone,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aNewName=%ls aClone=%p aProgress=%p\n", this, "CloudClient::cloneInstance", aUid, aNewName, aClone, 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(aClone);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpUid(aUid);
        BSTRInConverter TmpNewName(aNewName);
        ComTypeOutConverter<ICloudMachine> TmpClone(aClone);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CLONEINSTANCE_ENTER(this, TmpUid.str().c_str(), TmpNewName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = cloneInstance(TmpUid.str(),
                                TmpNewName.str(),
                                TmpClone.ptr(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CLONEINSTANCE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), TmpNewName.str().c_str(), (void *)TmpClone.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CLONEINSTANCE_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_CLOUDCLIENT_CLONEINSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClone=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::cloneInstance", !RT_VALID_PTR(aClone) ? 0 : *aClone, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::CreateImage(ComSafeArrayIn(IN_BSTR, aParameters),
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aParameters=%zu aProgress=%p\n", this, "CloudClient::createImage", aParameters, 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 TmpParameters(ComSafeArrayInArg(aParameters));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATEIMAGE_ENTER(this, (uint32_t)TmpParameters.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = createImage(TmpParameters.array(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATEIMAGE_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpParameters.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_CREATEIMAGE_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_CLOUDCLIENT_CREATEIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::createImage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ExportImage(IMedium *aImage,
                                          ComSafeArrayIn(IN_BSTR, aParameters),
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aImage=%p aParameters=%zu aProgress=%p\n", this, "CloudClient::exportImage", aImage, aParameters, 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<IMedium> TmpImage(aImage);
        ArrayBSTRInConverter TmpParameters(ComSafeArrayInArg(aParameters));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTIMAGE_ENTER(this, (void *)TmpImage.ptr(), (uint32_t)TmpParameters.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = exportImage(TmpImage.ptr(),
                              TmpParameters.array(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTIMAGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpImage.ptr(), (uint32_t)TmpParameters.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_EXPORTIMAGE_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_CLOUDCLIENT_EXPORTIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::exportImage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::ImportImage(IN_BSTR aUid,
                                          ComSafeArrayIn(IN_BSTR, aParameters),
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aParameters=%zu aProgress=%p\n", this, "CloudClient::importImage", aUid, aParameters, 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 TmpUid(aUid);
        ArrayBSTRInConverter TmpParameters(ComSafeArrayInArg(aParameters));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTIMAGE_ENTER(this, TmpUid.str().c_str(), (uint32_t)TmpParameters.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = importImage(TmpUid.str(),
                              TmpParameters.array(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTIMAGE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (uint32_t)TmpParameters.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_IMPORTIMAGE_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_CLOUDCLIENT_IMPORTIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::importImage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::DeleteImage(IN_BSTR aUid,
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aProgress=%p\n", this, "CloudClient::deleteImage", aUid, 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 TmpUid(aUid);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_DELETEIMAGE_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteImage(TmpUid.str(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_DELETEIMAGE_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_DELETEIMAGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_DELETEIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "CloudClient::deleteImage", !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetImageInfo(IN_BSTR aUid,
                                           IStringArray **aInfoArray,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aInfoArray=%p aProgress=%p\n", this, "CloudClient::getImageInfo", aUid, aInfoArray, 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(aInfoArray);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpUid(aUid);
        ComTypeOutConverter<IStringArray> TmpInfoArray(aInfoArray);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMAGEINFO_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getImageInfo(TmpUid.str(),
                               TmpInfoArray.ptr(),
                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMAGEINFO_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpInfoArray.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETIMAGEINFO_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_CLOUDCLIENT_GETIMAGEINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInfoArray=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getImageInfo", !RT_VALID_PTR(aInfoArray) ? 0 : *aInfoArray, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::StartCloudNetworkGateway(ICloudNetwork *aNetwork,
                                                       IN_BSTR aSshPublicKey,
                                                       ICloudNetworkGatewayInfo **aGatewayInfo,
                                                       IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p aSshPublicKey=%ls aGatewayInfo=%p aProgress=%p\n", this, "CloudClient::startCloudNetworkGateway", aNetwork, aSshPublicKey, aGatewayInfo, 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(aGatewayInfo);
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeInConverter<ICloudNetwork> TmpNetwork(aNetwork);
        BSTRInConverter TmpSshPublicKey(aSshPublicKey);
        ComTypeOutConverter<ICloudNetworkGatewayInfo> TmpGatewayInfo(aGatewayInfo);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTCLOUDNETWORKGATEWAY_ENTER(this, (void *)TmpNetwork.ptr(), TmpSshPublicKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = startCloudNetworkGateway(TmpNetwork.ptr(),
                                           TmpSshPublicKey.str(),
                                           TmpGatewayInfo.ptr(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTCLOUDNETWORKGATEWAY_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetwork.ptr(), TmpSshPublicKey.str().c_str(), (void *)TmpGatewayInfo.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_STARTCLOUDNETWORKGATEWAY_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_CLOUDCLIENT_STARTCLOUDNETWORKGATEWAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGatewayInfo=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::startCloudNetworkGateway", !RT_VALID_PTR(aGatewayInfo) ? 0 : *aGatewayInfo, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::SetupCloudNetworkEnvironment(IN_BSTR aTunnelNetworkName,
                                                           IN_BSTR aTunnelNetworkRange,
                                                           IN_BSTR aGatewayOsName,
                                                           IN_BSTR aGatewayOsVersion,
                                                           IN_BSTR aGatewayShape,
                                                           ICloudNetworkEnvironmentInfo **aNetworkEnvironmentInfo,
                                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aTunnelNetworkName=%ls aTunnelNetworkRange=%ls aGatewayOsName=%ls aGatewayOsVersion=%ls aGatewayShape=%ls aNetworkEnvironmentInfo=%p aProgress=%p\n", this, "CloudClient::setupCloudNetworkEnvironment", aTunnelNetworkName, aTunnelNetworkRange, aGatewayOsName, aGatewayOsVersion, aGatewayShape, aNetworkEnvironmentInfo, 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(aNetworkEnvironmentInfo);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpTunnelNetworkName(aTunnelNetworkName);
        BSTRInConverter TmpTunnelNetworkRange(aTunnelNetworkRange);
        BSTRInConverter TmpGatewayOsName(aGatewayOsName);
        BSTRInConverter TmpGatewayOsVersion(aGatewayOsVersion);
        BSTRInConverter TmpGatewayShape(aGatewayShape);
        ComTypeOutConverter<ICloudNetworkEnvironmentInfo> TmpNetworkEnvironmentInfo(aNetworkEnvironmentInfo);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_SETUPCLOUDNETWORKENVIRONMENT_ENTER(this, TmpTunnelNetworkName.str().c_str(), TmpTunnelNetworkRange.str().c_str(), TmpGatewayOsName.str().c_str(), TmpGatewayOsVersion.str().c_str(), TmpGatewayShape.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setupCloudNetworkEnvironment(TmpTunnelNetworkName.str(),
                                               TmpTunnelNetworkRange.str(),
                                               TmpGatewayOsName.str(),
                                               TmpGatewayOsVersion.str(),
                                               TmpGatewayShape.str(),
                                               TmpNetworkEnvironmentInfo.ptr(),
                                               TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_SETUPCLOUDNETWORKENVIRONMENT_RETURN(this, hrc, 0 /*normal*/, TmpTunnelNetworkName.str().c_str(), TmpTunnelNetworkRange.str().c_str(), TmpGatewayOsName.str().c_str(), TmpGatewayOsVersion.str().c_str(), TmpGatewayShape.str().c_str(), (void *)TmpNetworkEnvironmentInfo.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_SETUPCLOUDNETWORKENVIRONMENT_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_SETUPCLOUDNETWORKENVIRONMENT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetworkEnvironmentInfo=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::setupCloudNetworkEnvironment", !RT_VALID_PTR(aNetworkEnvironmentInfo) ? 0 : *aNetworkEnvironmentInfo, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetVnicInfo(IN_BSTR aUid,
                                          IStringArray **aInfoArray,
                                          IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aUid=%ls aInfoArray=%p aProgress=%p\n", this, "CloudClient::getVnicInfo", aUid, aInfoArray, 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(aInfoArray);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpUid(aUid);
        ComTypeOutConverter<IStringArray> TmpInfoArray(aInfoArray);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETVNICINFO_ENTER(this, TmpUid.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVnicInfo(TmpUid.str(),
                              TmpInfoArray.ptr(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETVNICINFO_RETURN(this, hrc, 0 /*normal*/, TmpUid.str().c_str(), (void *)TmpInfoArray.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETVNICINFO_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_CLOUDCLIENT_GETVNICINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInfoArray=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getVnicInfo", !RT_VALID_PTR(aInfoArray) ? 0 : *aInfoArray, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetSubnetSelectionForm(IVirtualSystemDescription *aDescription,
                                                     IVirtualSystemDescriptionForm **aForm,
                                                     IProgress **aProgress)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p aForm=%p aProgress=%p\n", this, "CloudClient::getSubnetSelectionForm", aDescription, 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);


        ComTypeInConverter<IVirtualSystemDescription> TmpDescription(aDescription);
        ComTypeOutConverter<IVirtualSystemDescriptionForm> TmpForm(aForm);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETSUBNETSELECTIONFORM_ENTER(this, (void *)TmpDescription.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubnetSelectionForm(TmpDescription.ptr(),
                                         TmpForm.ptr(),
                                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETSUBNETSELECTIONFORM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDescription.ptr(), (void *)TmpForm.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETSUBNETSELECTIONFORM_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_CLOUDCLIENT_GETSUBNETSELECTIONFORM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aForm=%p aProgress=%p hrc=%Rhrc\n", this, "CloudClient::getSubnetSelectionForm", !RT_VALID_PTR(aForm) ? 0 : *aForm, !RT_VALID_PTR(aProgress) ? 0 : *aProgress, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::GetMetricTypeByName(IN_BSTR aMetricName,
                                                  MetricType_T *aMetricType)
{
    LogRelFlow(("{%p} %s: enter aMetricName=%ls aMetricType=%p\n", this, "CloudClient::getMetricTypeByName", aMetricName, aMetricType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMetricType);


        BSTRInConverter TmpMetricName(aMetricName);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETMETRICTYPEBYNAME_ENTER(this, TmpMetricName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMetricTypeByName(TmpMetricName.str(),
                                      aMetricType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETMETRICTYPEBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpMetricName.str().c_str(), *aMetricType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETMETRICTYPEBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aMetricType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDCLIENT_GETMETRICTYPEBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aMetricType);
#endif
    }

    LogRelFlow(("{%p} %s: leave aMetricType=%RU32 hrc=%Rhrc\n", this, "CloudClient::getMetricTypeByName", !RT_VALID_PTR(aMetricType) ? 0 : *aMetricType, hrc));
    return hrc;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod1ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod2ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod3ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod4ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod5ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod6ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod7ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod8ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod9ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod10ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod11ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod12ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod13ICloudClient()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudClientWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudClientWrap, ICloudClient)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudClientWrap.cpp"


// ##### BEGINFILE "CloudProviderWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudProvider.
 *
 * 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_CLOUDPROVIDER

#include "CloudProviderWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudProviderWrap)

//
// ICloudProvider properties
//

STDMETHODIMP CloudProviderWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CloudProvider::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_CLOUDPROVIDER_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_CLOUDPROVIDER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_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_CLOUDPROVIDER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CloudProvider::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(ShortName)(BSTR *aShortName)
{
    LogRelFlow(("{%p} %s: enter aShortName=%p\n", this, "CloudProvider::getShortName", aShortName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShortName);
        BSTROutConverter TmpShortName(aShortName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SHORTNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShortName(TmpShortName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SHORTNAME_RETURN(this, hrc, 0 /*normal*/,TmpShortName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SHORTNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SHORTNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShortName=%ls hrc=%Rhrc\n", this, "CloudProvider::getShortName", !RT_VALID_PTR(aShortName) ? 0 : *aShortName, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "CloudProvider::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_CLOUDPROVIDER_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_CLOUDPROVIDER_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_CLOUDPROVIDER_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_CLOUDPROVIDER_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "CloudProvider::getId", !RT_VALID_PTR(aId) ? 0 : *aId, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(Profiles)(ComSafeArrayOut(ICloudProfile *, aProfiles))
{
    LogRelFlow(("{%p} %s: enter aProfiles=%p\n", this, "CloudProvider::getProfiles", aProfiles));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProfiles);
        ArrayComTypeOutConverter<ICloudProfile> TmpProfiles(ComSafeArrayOutArg(aProfiles));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProfiles(TmpProfiles.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProfiles.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProfiles=%zu hrc=%Rhrc\n", this, "CloudProvider::getProfiles", !RT_VALID_PTR(aProfiles) ? 0 : ComSafeArraySize(*aProfiles), hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(ProfileNames)(ComSafeArrayOut(BSTR, aProfileNames))
{
    LogRelFlow(("{%p} %s: enter aProfileNames=%p\n", this, "CloudProvider::getProfileNames", aProfileNames));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProfileNames);
        ArrayBSTROutConverter TmpProfileNames(ComSafeArrayOutArg(aProfileNames));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILENAMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProfileNames(TmpProfileNames.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILENAMES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProfileNames.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILENAMES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_PROFILENAMES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProfileNames=%zu hrc=%Rhrc\n", this, "CloudProvider::getProfileNames", !RT_VALID_PTR(aProfileNames) ? 0 : ComSafeArraySize(*aProfileNames), hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(SupportedPropertyNames)(ComSafeArrayOut(BSTR, aSupportedPropertyNames))
{
    LogRelFlow(("{%p} %s: enter aSupportedPropertyNames=%p\n", this, "CloudProvider::getSupportedPropertyNames", aSupportedPropertyNames));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupportedPropertyNames);
        ArrayBSTROutConverter TmpSupportedPropertyNames(ComSafeArrayOutArg(aSupportedPropertyNames));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SUPPORTEDPROPERTYNAMES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSupportedPropertyNames(TmpSupportedPropertyNames.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SUPPORTEDPROPERTYNAMES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSupportedPropertyNames.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SUPPORTEDPROPERTYNAMES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GET_SUPPORTEDPROPERTYNAMES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSupportedPropertyNames=%zu hrc=%Rhrc\n", this, "CloudProvider::getSupportedPropertyNames", !RT_VALID_PTR(aSupportedPropertyNames) ? 0 : ComSafeArraySize(*aSupportedPropertyNames), hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute1ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute2ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute3ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute4ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute5ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute6ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute7ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute8ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute9ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute10ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute11ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute12ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute13ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute14ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute15ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::COMGETTER(InternalAndReservedAttribute16ICloudProvider)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudProvider methods
//

STDMETHODIMP CloudProviderWrap::GetPropertyDescription(IN_BSTR aName,
                                                       BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aName=%ls aDescription=%p\n", this, "CloudProvider::getPropertyDescription", aName, 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);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROPERTYDESCRIPTION_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPropertyDescription(TmpName.str(),
                                         TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROPERTYDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROPERTYDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROPERTYDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDescription=%ls hrc=%Rhrc\n", this, "CloudProvider::getPropertyDescription", !RT_VALID_PTR(aDescription) ? 0 : *aDescription, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::CreateProfile(IN_BSTR aProfileName,
                                              ComSafeArrayIn(IN_BSTR, aNames),
                                              ComSafeArrayIn(IN_BSTR, aValues))
{
    LogRelFlow(("{%p} %s: enter aProfileName=%ls aNames=%zu aValues=%zu\n", this, "CloudProvider::createProfile", aProfileName, 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
    {


        BSTRInConverter TmpProfileName(aProfileName);
        ArrayBSTRInConverter TmpNames(ComSafeArrayInArg(aNames));
        ArrayBSTRInConverter TmpValues(ComSafeArrayInArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_CREATEPROFILE_ENTER(this, TmpProfileName.str().c_str(), (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 = createProfile(TmpProfileName.str(),
                                TmpNames.array(),
                                TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_CREATEPROFILE_RETURN(this, hrc, 0 /*normal*/, TmpProfileName.str().c_str(), (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_CLOUDPROVIDER_CREATEPROFILE_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_CLOUDPROVIDER_CREATEPROFILE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProvider::createProfile", hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::ImportProfiles()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProvider::importProfiles"));

    // Clear 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_CLOUDPROVIDER_IMPORTPROFILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = importProfiles();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_IMPORTPROFILES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_IMPORTPROFILES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_IMPORTPROFILES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProvider::importProfiles", hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::RestoreProfiles()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProvider::restoreProfiles"));

    // Clear 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_CLOUDPROVIDER_RESTOREPROFILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = restoreProfiles();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_RESTOREPROFILES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_RESTOREPROFILES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_RESTOREPROFILES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProvider::restoreProfiles", hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::SaveProfiles()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProvider::saveProfiles"));

    // Clear 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_CLOUDPROVIDER_SAVEPROFILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = saveProfiles();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_SAVEPROFILES_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_SAVEPROFILES_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_SAVEPROFILES_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProvider::saveProfiles", hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::GetProfileByName(IN_BSTR aProfileName,
                                                 ICloudProfile **aProfile)
{
    LogRelFlow(("{%p} %s: enter aProfileName=%ls aProfile=%p\n", this, "CloudProvider::getProfileByName", aProfileName, 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);


        BSTRInConverter TmpProfileName(aProfileName);
        ComTypeOutConverter<ICloudProfile> TmpProfile(aProfile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROFILEBYNAME_ENTER(this, TmpProfileName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProfileByName(TmpProfileName.str(),
                                   TmpProfile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROFILEBYNAME_RETURN(this, hrc, 0 /*normal*/, TmpProfileName.str().c_str(), (void *)TmpProfile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROFILEBYNAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_GETPROFILEBYNAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProfile=%p hrc=%Rhrc\n", this, "CloudProvider::getProfileByName", !RT_VALID_PTR(aProfile) ? 0 : *aProfile, hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::PrepareUninstall()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProvider::prepareUninstall"));

    // Clear 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_CLOUDPROVIDER_PREPAREUNINSTALL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = prepareUninstall(autoCaller);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_PREPAREUNINSTALL_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_PREPAREUNINSTALL_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROVIDER_PREPAREUNINSTALL_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProvider::prepareUninstall", hrc));
    return hrc;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod1ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod2ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod3ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod4ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod5ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod6ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod7ICloudProvider()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudProviderWrap::InternalAndReservedMethod8ICloudProvider()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudProviderWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudProviderWrap, ICloudProvider)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudProviderWrap.cpp"


// ##### BEGINFILE "CloudProfileChangedEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudProfileChangedEvent.
 *
 * 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_CLOUDPROFILECHANGEDEVENT

#include "CloudProfileChangedEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudProfileChangedEventWrap)

//
// IEvent properties
//

STDMETHODIMP CloudProfileChangedEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "CloudProfileChangedEvent::getType", !RT_VALID_PTR(aType) ? 0 : *aType, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileChangedEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "CloudProfileChangedEvent::getSource", !RT_VALID_PTR(aSource) ? 0 : *aSource, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileChangedEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "CloudProfileChangedEvent::getWaitable", !RT_VALID_PTR(aWaitable) ? 0 : *aWaitable, hrc));
    return hrc;
}

//
// ICloudProfileChangedEvent properties
//

STDMETHODIMP CloudProfileChangedEventWrap::COMGETTER(ProviderId)(BSTR *aProviderId)
{
    LogRelFlow(("{%p} %s: enter aProviderId=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_PROVIDERID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProviderId=%ls hrc=%Rhrc\n", this, "CloudProfileChangedEvent::getProviderId", !RT_VALID_PTR(aProviderId) ? 0 : *aProviderId, hrc));
    return hrc;
}

STDMETHODIMP CloudProfileChangedEventWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "CloudProfileChangedEvent::getName", !RT_VALID_PTR(aName) ? 0 : *aName, hrc));
    return hrc;
}


//
// IEvent methods
//

STDMETHODIMP CloudProfileChangedEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s: enter\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.hrc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "CloudProfileChangedEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP CloudProfileChangedEventWrap::WaitProcessed(LONG aTimeout,
                                                         BOOL *aResult)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RI32 aResult=%p\n", this, "CloudProfileChangedEvent::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_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDPROFILECHANGEDEVENT_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_CLOUDPROFILECHANGEDEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "CloudProfileChangedEvent::waitProcessed", !RT_VALID_PTR(aResult) ? 0 : *aResult, hrc));
    return hrc;
}

//
// ICloudProfileChangedEvent methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudProfileChangedEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(CloudProfileChangedEventWrap, ICloudProfileChangedEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudProfileChangedEventWrap.cpp"
