

// ##### 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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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", 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.rc();
        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", ComSafeArraySize(*aLocalMappings), 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.rc();
        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", *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.rc();
        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.rc();
        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", 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.rc();
        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.rc();
        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.rc();
        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.rc();
        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.rc();
        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;
}

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPSERVER

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

DEFINE_EMPTY_CTOR_DTOR(DHCPServerWrap)

//
// IDHCPServer properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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


//
// IDHCPServer methods
//

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

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

    HRESULT hrc;

    try
    {


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

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

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

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

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

    HRESULT hrc;

    try
    {


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

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

    HRESULT hrc;

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


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConfig);


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

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

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

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPGLOBALCONFIG

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

DEFINE_EMPTY_CTOR_DTOR(DHCPGlobalConfigWrap)

//
// IDHCPConfig properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//
// IDHCPGlobalConfig properties
//

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

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

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

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


//
// IDHCPConfig methods
//

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

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

    HRESULT hrc;

    try
    {


        
        
        BSTRInConverter TmpValue(aValue);

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

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

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

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

    HRESULT hrc;

    try
    {


        

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

    HRESULT hrc;

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


        
        
        BSTROutConverter TmpValue(aValue);

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

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

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

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

    HRESULT hrc;

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


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

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

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

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

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

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

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

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

//
// IDHCPGlobalConfig methods
//

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

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

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

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

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DHCPGROUPCONFIG

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

DEFINE_EMPTY_CTOR_DTOR(DHCPGroupConfigWrap)

//
// IDHCPConfig properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//
// IDHCPGroupConfig properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

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

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

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

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

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


//
// IDHCPConfig methods
//

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

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

    HRESULT hrc;

    try
    {


        
        
        BSTRInConverter TmpValue(aValue);

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

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

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

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

    HRESULT hrc;

    try
    {


        

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

    HRESULT hrc;

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


        
        
        BSTROutConverter TmpValue(aValue);

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

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

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

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

    HRESULT hrc;

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


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

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

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

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

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

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

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

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

//
// IDHCPGroupConfig methods
//

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCondition);


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

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

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

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

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

    HRESULT hrc;

    try
    {



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

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

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

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

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

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

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

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

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

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

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALBOX

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

DEFINE_EMPTY_CTOR_DTOR(VirtualBoxWrap)

//
// IVirtualBox properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


//
// IVirtualBox methods
//

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


        BSTRInConverter TmpSettingsFile(aSettingsFile);
        BSTRInConverter TmpName(aName);
        ArrayBSTRInConverter TmpGroups(ComSafeArrayInArg(aGroups));
        BSTRInConverter TmpOsTypeId(aOsTypeId);
        BSTRInConverter TmpFlags(aFlags);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


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

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

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

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

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

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachines);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStates);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAppliance);


        ComTypeOutConverter<IAppliance> TmpAppliance(aAppliance);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUnattended);


        ComTypeOutConverter<IUnattended> TmpUnattended(aUnattended);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);


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

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

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

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

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

    HRESULT hrc;

    try
    {


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

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

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

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

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

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeys);


        ArrayBSTROutConverter TmpKeys(ComSafeArrayOutArg(aKeys));

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


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

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

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

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

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

    HRESULT hrc;

    try
    {


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

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

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

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

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

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPassword(aPassword);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);


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

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

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

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

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

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IDHCPServer> TmpServer(aServer);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


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

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

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

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

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

    HRESULT hrc;

    try
    {


        ComTypeInConverter<INATNetwork> TmpNetwork(aNetwork);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);


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

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

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

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

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

    HRESULT hrc;

    try
    {


        ComTypeInConverter<ICloudNetwork> TmpNetwork(aNetwork);

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

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

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

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

    HRESULT hrc;

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_VFSEXPLORER

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

DEFINE_EMPTY_CTOR_DTOR(VFSExplorerWrap)

//
// IVFSExplorer properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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


//
// IVFSExplorer methods
//

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

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

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

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

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

    HRESULT hrc;

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


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


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

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

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

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

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


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

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

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

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

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


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_CERTIFICATE

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

DEFINE_EMPTY_CTOR_DTOR(CertificateWrap)

//
// ICertificate properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

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

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

STDMETHODIMP CertificateWrap::COMGETTER(SubjectPublicKey)(ComSafeArrayOut(BYTE, aSubjectPublicKey))
{
    LogRelFlow(("{%p} %s: enter aSubjectPublicKey=%p\n", this, "Certificate::getSubjectPublicKey", aSubjectPublicKey));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubjectPublicKey);
        ArrayOutConverter<BYTE> TmpSubjectPublicKey(ComSafeArrayOutArg(aSubjectPublicKey));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubjectPublicKey(TmpSubjectPublicKey.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpSubjectPublicKey.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTPUBLICKEY_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubjectPublicKey=%zu hrc=%Rhrc\n", this, "Certificate::getSubjectPublicKey", ComSafeArraySize(*aSubjectPublicKey), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(IssuerUniqueIdentifier)(BSTR *aIssuerUniqueIdentifier)
{
    LogRelFlow(("{%p} %s: enter aIssuerUniqueIdentifier=%p\n", this, "Certificate::getIssuerUniqueIdentifier", aIssuerUniqueIdentifier));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIssuerUniqueIdentifier);
        BSTROutConverter TmpIssuerUniqueIdentifier(aIssuerUniqueIdentifier);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIssuerUniqueIdentifier(TmpIssuerUniqueIdentifier.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 0 /*normal*/,TmpIssuerUniqueIdentifier.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_ISSUERUNIQUEIDENTIFIER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIssuerUniqueIdentifier=%ls hrc=%Rhrc\n", this, "Certificate::getIssuerUniqueIdentifier", *aIssuerUniqueIdentifier, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SubjectUniqueIdentifier)(BSTR *aSubjectUniqueIdentifier)
{
    LogRelFlow(("{%p} %s: enter aSubjectUniqueIdentifier=%p\n", this, "Certificate::getSubjectUniqueIdentifier", aSubjectUniqueIdentifier));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSubjectUniqueIdentifier);
        BSTROutConverter TmpSubjectUniqueIdentifier(aSubjectUniqueIdentifier);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSubjectUniqueIdentifier(TmpSubjectUniqueIdentifier.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 0 /*normal*/,TmpSubjectUniqueIdentifier.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_SUBJECTUNIQUEIDENTIFIER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSubjectUniqueIdentifier=%ls hrc=%Rhrc\n", this, "Certificate::getSubjectUniqueIdentifier", *aSubjectUniqueIdentifier, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(CertificateAuthority)(BOOL *aCertificateAuthority)
{
    LogRelFlow(("{%p} %s: enter aCertificateAuthority=%p\n", this, "Certificate::getCertificateAuthority", aCertificateAuthority));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aCertificateAuthority=%RTbool hrc=%Rhrc\n", this, "Certificate::getCertificateAuthority", *aCertificateAuthority, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(KeyUsage)(ULONG *aKeyUsage)
{
    LogRelFlow(("{%p} %s: enter aKeyUsage=%p\n", this, "Certificate::getKeyUsage", aKeyUsage));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeyUsage);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getKeyUsage(aKeyUsage);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 0 /*normal*/,*aKeyUsage);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 1 /*hrc exception*/,*aKeyUsage);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_KEYUSAGE_RETURN(this, hrc, 9 /*unhandled exception*/,*aKeyUsage);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeyUsage=%RU32 hrc=%Rhrc\n", this, "Certificate::getKeyUsage", *aKeyUsage, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(ExtendedKeyUsage)(ComSafeArrayOut(BSTR, aExtendedKeyUsage))
{
    LogRelFlow(("{%p} %s: enter aExtendedKeyUsage=%p\n", this, "Certificate::getExtendedKeyUsage", aExtendedKeyUsage));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtendedKeyUsage);
        ArrayBSTROutConverter TmpExtendedKeyUsage(ComSafeArrayOutArg(aExtendedKeyUsage));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtendedKeyUsage(TmpExtendedKeyUsage.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpExtendedKeyUsage.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_EXTENDEDKEYUSAGE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtendedKeyUsage=%zu hrc=%Rhrc\n", this, "Certificate::getExtendedKeyUsage", ComSafeArraySize(*aExtendedKeyUsage), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(RawCertData)(ComSafeArrayOut(BYTE, aRawCertData))
{
    LogRelFlow(("{%p} %s: enter aRawCertData=%p\n", this, "Certificate::getRawCertData", aRawCertData));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRawCertData);
        ArrayOutConverter<BYTE> TmpRawCertData(ComSafeArrayOutArg(aRawCertData));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRawCertData(TmpRawCertData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpRawCertData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_GET_RAWCERTDATA_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRawCertData=%zu hrc=%Rhrc\n", this, "Certificate::getRawCertData", ComSafeArraySize(*aRawCertData), hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(SelfSigned)(BOOL *aSelfSigned)
{
    LogRelFlow(("{%p} %s: enter aSelfSigned=%p\n", this, "Certificate::getSelfSigned", aSelfSigned));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aSelfSigned=%RTbool hrc=%Rhrc\n", this, "Certificate::getSelfSigned", *aSelfSigned, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(Trusted)(BOOL *aTrusted)
{
    LogRelFlow(("{%p} %s: enter aTrusted=%p\n", this, "Certificate::getTrusted", aTrusted));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aTrusted=%RTbool hrc=%Rhrc\n", this, "Certificate::getTrusted", *aTrusted, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(Expired)(BOOL *aExpired)
{
    LogRelFlow(("{%p} %s: enter aExpired=%p\n", this, "Certificate::getExpired", aExpired));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aExpired=%RTbool hrc=%Rhrc\n", this, "Certificate::getExpired", *aExpired, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute1ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute2ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute3ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute4ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute5ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute6ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute7ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute8ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute9ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute10ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute11ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::COMGETTER(InternalAndReservedAttribute12ICertificate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICertificate methods
//

STDMETHODIMP CertificateWrap::IsCurrentlyExpired(BOOL *aResult)
{
    LogRelFlow(("{%p} %s:enter aResult=%p\n", this, "Certificate::isCurrentlyExpired", aResult));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = isCurrentlyExpired(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_ISCURRENTLYEXPIRED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "Certificate::isCurrentlyExpired", *aResult, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::QueryInfo(LONG aWhat,
                                        BSTR *aResult)
{
    LogRelFlow(("{%p} %s:enter aWhat=%RI32 aResult=%p\n", this, "Certificate::queryInfo", aWhat, aResult));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        BSTROutConverter TmpResult(aResult);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_ENTER(this, aWhat);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryInfo(aWhat,
                            TmpResult.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 0 /*normal*/, aWhat, TmpResult.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, aWhat, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CERTIFICATE_QUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, aWhat, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%ls hrc=%Rhrc\n", this, "Certificate::queryInfo", *aResult, hrc));
    return hrc;
}

STDMETHODIMP CertificateWrap::InternalAndReservedMethod1ICertificate()
{
    return E_NOTIMPL;
}

STDMETHODIMP CertificateWrap::InternalAndReservedMethod2ICertificate()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CertificateWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CertificateWrap, ICertificate)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CertificateWrap.cpp"


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALSYSTEMDESCRIPTION

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

DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescriptionWrap)

//
// IVirtualSystemDescription properties
//

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(Count)(ULONG *aCount)
{
    LogRelFlow(("{%p} %s: enter aCount=%p\n", this, "VirtualSystemDescription::getCount", aCount));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCount(aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 0 /*normal*/,*aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GET_COUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCount=%RU32 hrc=%Rhrc\n", this, "VirtualSystemDescription::getCount", *aCount, hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescription)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVirtualSystemDescription methods
//

STDMETHODIMP VirtualSystemDescriptionWrap::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                                                          ComSafeArrayOut(BSTR, aRefs),
                                                          ComSafeArrayOut(BSTR, aOVFValues),
                                                          ComSafeArrayOut(BSTR, aVBoxValues),
                                                          ComSafeArrayOut(BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s:enter aTypes=%p aRefs=%p aOVFValues=%p aVBoxValues=%p aExtraConfigValues=%p\n", this, "VirtualSystemDescription::getDescription", aTypes, aRefs, aOVFValues, aVBoxValues, aExtraConfigValues));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aRefs);
        CheckComArgOutPointerValidThrow(aOVFValues);
        CheckComArgOutPointerValidThrow(aVBoxValues);
        CheckComArgOutPointerValidThrow(aExtraConfigValues);


        ArrayOutConverter<VirtualSystemDescriptionType_T> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayBSTROutConverter TmpRefs(ComSafeArrayOutArg(aRefs));
        ArrayBSTROutConverter TmpOVFValues(ComSafeArrayOutArg(aOVFValues));
        ArrayBSTROutConverter TmpVBoxValues(ComSafeArrayOutArg(aVBoxValues));
        ArrayBSTROutConverter TmpExtraConfigValues(ComSafeArrayOutArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpTypes.array(),
                                 TmpRefs.array(),
                                 TmpOVFValues.array(),
                                 TmpVBoxValues.array(),
                                 TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpRefs.array().size(), NULL /*for now*/, (uint32_t)TmpOVFValues.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypes=%zu *aRefs=%zu *aOVFValues=%zu *aVBoxValues=%zu *aExtraConfigValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getDescription", ComSafeArraySize(*aTypes), ComSafeArraySize(*aRefs), ComSafeArraySize(*aOVFValues), ComSafeArraySize(*aVBoxValues), ComSafeArraySize(*aExtraConfigValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::GetDescriptionByType(VirtualSystemDescriptionType_T aType,
                                                                ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                                                                ComSafeArrayOut(BSTR, aRefs),
                                                                ComSafeArrayOut(BSTR, aOVFValues),
                                                                ComSafeArrayOut(BSTR, aVBoxValues),
                                                                ComSafeArrayOut(BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s:enter aType=%RU32 aTypes=%p aRefs=%p aOVFValues=%p aVBoxValues=%p aExtraConfigValues=%p\n", this, "VirtualSystemDescription::getDescriptionByType", aType, aTypes, aRefs, aOVFValues, aVBoxValues, aExtraConfigValues));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTypes);
        CheckComArgOutPointerValidThrow(aRefs);
        CheckComArgOutPointerValidThrow(aOVFValues);
        CheckComArgOutPointerValidThrow(aVBoxValues);
        CheckComArgOutPointerValidThrow(aExtraConfigValues);


        
        ArrayOutConverter<VirtualSystemDescriptionType_T> TmpTypes(ComSafeArrayOutArg(aTypes));
        ArrayBSTROutConverter TmpRefs(ComSafeArrayOutArg(aRefs));
        ArrayBSTROutConverter TmpOVFValues(ComSafeArrayOutArg(aOVFValues));
        ArrayBSTROutConverter TmpVBoxValues(ComSafeArrayOutArg(aVBoxValues));
        ArrayBSTROutConverter TmpExtraConfigValues(ComSafeArrayOutArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_ENTER(this, aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescriptionByType(aType,
                                       TmpTypes.array(),
                                       TmpRefs.array(),
                                       TmpOVFValues.array(),
                                       TmpVBoxValues.array(),
                                       TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType, (uint32_t)TmpTypes.array().size(), NULL /*for now*/, (uint32_t)TmpRefs.array().size(), NULL /*for now*/, (uint32_t)TmpOVFValues.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETDESCRIPTIONBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTypes=%zu *aRefs=%zu *aOVFValues=%zu *aVBoxValues=%zu *aExtraConfigValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getDescriptionByType", ComSafeArraySize(*aTypes), ComSafeArraySize(*aRefs), ComSafeArraySize(*aOVFValues), ComSafeArraySize(*aVBoxValues), ComSafeArraySize(*aExtraConfigValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::RemoveDescriptionByType(VirtualSystemDescriptionType_T aType)
{
    LogRelFlow(("{%p} %s:enter aType=%RU32\n", this, "VirtualSystemDescription::removeDescriptionByType", aType));

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

    HRESULT hrc;

    try
    {


        

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

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

STDMETHODIMP VirtualSystemDescriptionWrap::GetValuesByType(VirtualSystemDescriptionType_T aType,
                                                           VirtualSystemDescriptionValueType_T aWhich,
                                                           ComSafeArrayOut(BSTR, aValues))
{
    LogRelFlow(("{%p} %s:enter aType=%RU32 aWhich=%RU32 aValues=%p\n", this, "VirtualSystemDescription::getValuesByType", aType, aWhich, aValues));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);


        
        
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_ENTER(this, aType, aWhich);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValuesByType(aType,
                                  aWhich,
                                  TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 0 /*normal*/, aType, aWhich, (uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 1 /*hrc exception*/, aType, aWhich, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_GETVALUESBYTYPE_RETURN(this, hrc, 9 /*unhandled exception*/, aType, aWhich, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValues=%zu hrc=%Rhrc\n", this, "VirtualSystemDescription::getValuesByType", ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP VirtualSystemDescriptionWrap::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
                                                          ComSafeArrayIn(IN_BSTR, aVBoxValues),
                                                          ComSafeArrayIn(IN_BSTR, aExtraConfigValues))
{
    LogRelFlow(("{%p} %s:enter aEnabled=%zu aVBoxValues=%zu aExtraConfigValues=%zu\n", this, "VirtualSystemDescription::setFinalValues", aEnabled, aVBoxValues, aExtraConfigValues));

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

    HRESULT hrc;

    try
    {


        ArrayInConverter<BOOL> TmpEnabled(ComSafeArrayInArg(aEnabled));
        ArrayBSTRInConverter TmpVBoxValues(ComSafeArrayInArg(aVBoxValues));
        ArrayBSTRInConverter TmpExtraConfigValues(ComSafeArrayInArg(aExtraConfigValues));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_ENTER(this, (uint32_t)TmpEnabled.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setFinalValues(TmpEnabled.array(),
                                 TmpVBoxValues.array(),
                                 TmpExtraConfigValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpEnabled.array().size(), NULL /*for now*/, (uint32_t)TmpVBoxValues.array().size(), NULL /*for now*/, (uint32_t)TmpExtraConfigValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_SETFINALVALUES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

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

STDMETHODIMP VirtualSystemDescriptionWrap::AddDescription(VirtualSystemDescriptionType_T aType,
                                                          IN_BSTR aVBoxValue,
                                                          IN_BSTR aExtraConfigValue)
{
    LogRelFlow(("{%p} %s:enter aType=%RU32 aVBoxValue=%ls aExtraConfigValue=%ls\n", this, "VirtualSystemDescription::addDescription", aType, aVBoxValue, aExtraConfigValue));

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

    HRESULT hrc;

    try
    {


        
        BSTRInConverter TmpVBoxValue(aVBoxValue);
        BSTRInConverter TmpExtraConfigValue(aExtraConfigValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_ENTER(this, aType, TmpVBoxValue.str().c_str(), TmpExtraConfigValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addDescription(aType,
                                 TmpVBoxValue.str(),
                                 TmpExtraConfigValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 0 /*normal*/, aType, TmpVBoxValue.str().c_str(), TmpExtraConfigValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VIRTUALSYSTEMDESCRIPTION_ADDDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

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

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod1IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod2IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod3IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

STDMETHODIMP VirtualSystemDescriptionWrap::InternalAndReservedMethod4IVirtualSystemDescription()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VirtualSystemDescriptionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VirtualSystemDescriptionWrap, IVirtualSystemDescription)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VirtualSystemDescriptionWrap.cpp"


// ##### BEGINFILE "BIOSSettingsWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IBIOSSettings.
 *
 * 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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_BIOSSETTINGS

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

DEFINE_EMPTY_CTOR_DTOR(BIOSSettingsWrap)

//
// IBIOSSettings properties
//

STDMETHODIMP BIOSSettingsWrap::COMGETTER(LogoFadeIn)(BOOL *aLogoFadeIn)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeIn=%p\n", this, "BIOSSettings::getLogoFadeIn", aLogoFadeIn));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aLogoFadeIn=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getLogoFadeIn", *aLogoFadeIn, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(LogoFadeIn)(BOOL aLogoFadeIn)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeIn=%RTbool\n", this, "BIOSSettings::setLogoFadeIn", aLogoFadeIn));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEIN_ENTER(this, aLogoFadeIn != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoFadeIn(aLogoFadeIn != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 0 /*normal*/,aLogoFadeIn != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 1 /*hrc exception*/,aLogoFadeIn != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEIN_RETURN(this, hrc, 9 /*unhandled exception*/,aLogoFadeIn != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(LogoFadeOut)(BOOL *aLogoFadeOut)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeOut=%p\n", this, "BIOSSettings::getLogoFadeOut", aLogoFadeOut));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aLogoFadeOut=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getLogoFadeOut", *aLogoFadeOut, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(LogoFadeOut)(BOOL aLogoFadeOut)
{
    LogRelFlow(("{%p} %s: enter aLogoFadeOut=%RTbool\n", this, "BIOSSettings::setLogoFadeOut", aLogoFadeOut));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEOUT_ENTER(this, aLogoFadeOut != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoFadeOut(aLogoFadeOut != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 0 /*normal*/,aLogoFadeOut != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aLogoFadeOut != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOFADEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aLogoFadeOut != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(LogoDisplayTime)(ULONG *aLogoDisplayTime)
{
    LogRelFlow(("{%p} %s: enter aLogoDisplayTime=%p\n", this, "BIOSSettings::getLogoDisplayTime", aLogoDisplayTime));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoDisplayTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGODISPLAYTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoDisplayTime(aLogoDisplayTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 0 /*normal*/,*aLogoDisplayTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aLogoDisplayTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGODISPLAYTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aLogoDisplayTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoDisplayTime=%RU32 hrc=%Rhrc\n", this, "BIOSSettings::getLogoDisplayTime", *aLogoDisplayTime, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(LogoDisplayTime)(ULONG aLogoDisplayTime)
{
    LogRelFlow(("{%p} %s: enter aLogoDisplayTime=%RU32\n", this, "BIOSSettings::setLogoDisplayTime", aLogoDisplayTime));

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

    HRESULT hrc;

    try
    {
        

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

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(LogoImagePath)(BSTR *aLogoImagePath)
{
    LogRelFlow(("{%p} %s: enter aLogoImagePath=%p\n", this, "BIOSSettings::getLogoImagePath", aLogoImagePath));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLogoImagePath);
        BSTROutConverter TmpLogoImagePath(aLogoImagePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGOIMAGEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLogoImagePath(TmpLogoImagePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 0 /*normal*/,TmpLogoImagePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_LOGOIMAGEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLogoImagePath=%ls hrc=%Rhrc\n", this, "BIOSSettings::getLogoImagePath", *aLogoImagePath, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(LogoImagePath)(IN_BSTR aLogoImagePath)
{
    LogRelFlow(("{%p} %s: enter aLogoImagePath=%ls\n", this, "BIOSSettings::setLogoImagePath", aLogoImagePath));

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

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpLogoImagePath(aLogoImagePath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOIMAGEPATH_ENTER(this, TmpLogoImagePath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setLogoImagePath(TmpLogoImagePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 0 /*normal*/,TmpLogoImagePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_LOGOIMAGEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(BootMenuMode)(BIOSBootMenuMode_T *aBootMenuMode)
{
    LogRelFlow(("{%p} %s: enter aBootMenuMode=%p\n", this, "BIOSSettings::getBootMenuMode", aBootMenuMode));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBootMenuMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_BOOTMENUMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootMenuMode(aBootMenuMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 0 /*normal*/,*aBootMenuMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aBootMenuMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_BOOTMENUMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBootMenuMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBootMenuMode=%RU32 hrc=%Rhrc\n", this, "BIOSSettings::getBootMenuMode", *aBootMenuMode, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(BootMenuMode)(BIOSBootMenuMode_T aBootMenuMode)
{
    LogRelFlow(("{%p} %s: enter aBootMenuMode=%RU32\n", this, "BIOSSettings::setBootMenuMode", aBootMenuMode));

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

    HRESULT hrc;

    try
    {
        

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

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(ACPIEnabled)(BOOL *aACPIEnabled)
{
    LogRelFlow(("{%p} %s: enter aACPIEnabled=%p\n", this, "BIOSSettings::getACPIEnabled", aACPIEnabled));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aACPIEnabled=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getACPIEnabled", *aACPIEnabled, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(ACPIEnabled)(BOOL aACPIEnabled)
{
    LogRelFlow(("{%p} %s: enter aACPIEnabled=%RTbool\n", this, "BIOSSettings::setACPIEnabled", aACPIEnabled));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_ACPIENABLED_ENTER(this, aACPIEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setACPIEnabled(aACPIEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 0 /*normal*/,aACPIEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aACPIEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_ACPIENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aACPIEnabled != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(IOAPICEnabled)(BOOL *aIOAPICEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOAPICEnabled=%p\n", this, "BIOSSettings::getIOAPICEnabled", aIOAPICEnabled));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aIOAPICEnabled=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getIOAPICEnabled", *aIOAPICEnabled, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(IOAPICEnabled)(BOOL aIOAPICEnabled)
{
    LogRelFlow(("{%p} %s: enter aIOAPICEnabled=%RTbool\n", this, "BIOSSettings::setIOAPICEnabled", aIOAPICEnabled));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_IOAPICENABLED_ENTER(this, aIOAPICEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOAPICEnabled(aIOAPICEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 0 /*normal*/,aIOAPICEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aIOAPICEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_IOAPICENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aIOAPICEnabled != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(APICMode)(APICMode_T *aAPICMode)
{
    LogRelFlow(("{%p} %s: enter aAPICMode=%p\n", this, "BIOSSettings::getAPICMode", aAPICMode));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAPICMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_APICMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAPICMode(aAPICMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_APICMODE_RETURN(this, hrc, 0 /*normal*/,*aAPICMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_APICMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAPICMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_APICMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAPICMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAPICMode=%RU32 hrc=%Rhrc\n", this, "BIOSSettings::getAPICMode", *aAPICMode, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(APICMode)(APICMode_T aAPICMode)
{
    LogRelFlow(("{%p} %s: enter aAPICMode=%RU32\n", this, "BIOSSettings::setAPICMode", aAPICMode));

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

    HRESULT hrc;

    try
    {
        

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

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(TimeOffset)(LONG64 *aTimeOffset)
{
    LogRelFlow(("{%p} %s: enter aTimeOffset=%p\n", this, "BIOSSettings::getTimeOffset", aTimeOffset));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeOffset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_TIMEOFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeOffset(aTimeOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 0 /*normal*/,*aTimeOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_TIMEOFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeOffset=%RI64 hrc=%Rhrc\n", this, "BIOSSettings::getTimeOffset", *aTimeOffset, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(TimeOffset)(LONG64 aTimeOffset)
{
    LogRelFlow(("{%p} %s: enter aTimeOffset=%RI64\n", this, "BIOSSettings::setTimeOffset", aTimeOffset));

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

    HRESULT hrc;

    try
    {
        

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

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(PXEDebugEnabled)(BOOL *aPXEDebugEnabled)
{
    LogRelFlow(("{%p} %s: enter aPXEDebugEnabled=%p\n", this, "BIOSSettings::getPXEDebugEnabled", aPXEDebugEnabled));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aPXEDebugEnabled=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getPXEDebugEnabled", *aPXEDebugEnabled, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(PXEDebugEnabled)(BOOL aPXEDebugEnabled)
{
    LogRelFlow(("{%p} %s: enter aPXEDebugEnabled=%RTbool\n", this, "BIOSSettings::setPXEDebugEnabled", aPXEDebugEnabled));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_PXEDEBUGENABLED_ENTER(this, aPXEDebugEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPXEDebugEnabled(aPXEDebugEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 0 /*normal*/,aPXEDebugEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aPXEDebugEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_PXEDEBUGENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aPXEDebugEnabled != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(NonVolatileStorageFile)(BSTR *aNonVolatileStorageFile)
{
    LogRelFlow(("{%p} %s: enter aNonVolatileStorageFile=%p\n", this, "BIOSSettings::getNonVolatileStorageFile", aNonVolatileStorageFile));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNonVolatileStorageFile);
        BSTROutConverter TmpNonVolatileStorageFile(aNonVolatileStorageFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_NONVOLATILESTORAGEFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNonVolatileStorageFile(TmpNonVolatileStorageFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 0 /*normal*/,TmpNonVolatileStorageFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_GET_NONVOLATILESTORAGEFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNonVolatileStorageFile=%ls hrc=%Rhrc\n", this, "BIOSSettings::getNonVolatileStorageFile", *aNonVolatileStorageFile, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(SMBIOSUuidLittleEndian)(BOOL *aSMBIOSUuidLittleEndian)
{
    LogRelFlow(("{%p} %s: enter aSMBIOSUuidLittleEndian=%p\n", this, "BIOSSettings::getSMBIOSUuidLittleEndian", aSMBIOSUuidLittleEndian));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aSMBIOSUuidLittleEndian=%RTbool hrc=%Rhrc\n", this, "BIOSSettings::getSMBIOSUuidLittleEndian", *aSMBIOSUuidLittleEndian, hrc));
    return hrc;
}

STDMETHODIMP BIOSSettingsWrap::COMSETTER(SMBIOSUuidLittleEndian)(BOOL aSMBIOSUuidLittleEndian)
{
    LogRelFlow(("{%p} %s: enter aSMBIOSUuidLittleEndian=%RTbool\n", this, "BIOSSettings::setSMBIOSUuidLittleEndian", aSMBIOSUuidLittleEndian));

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

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_ENTER(this, aSMBIOSUuidLittleEndian != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSMBIOSUuidLittleEndian(aSMBIOSUuidLittleEndian != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 0 /*normal*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 1 /*hrc exception*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BIOSSETTINGS_SET_SMBIOSUUIDLITTLEENDIAN_RETURN(this, hrc, 9 /*unhandled exception*/,aSMBIOSUuidLittleEndian != FALSE);
#endif
    }

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

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute1IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute2IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute3IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute4IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute5IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute6IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute7IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::COMGETTER(InternalAndReservedAttribute8IBIOSSettings)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IBIOSSettings methods
//

STDMETHODIMP BIOSSettingsWrap::InternalAndReservedMethod1IBIOSSettings()
{
    return E_NOTIMPL;
}

STDMETHODIMP BIOSSettingsWrap::InternalAndReservedMethod2IBIOSSettings()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(BIOSSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BIOSSettingsWrap, IBIOSSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "BIOSSettingsWrap.cpp"


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_RECORDINGSETTINGS

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

DEFINE_EMPTY_CTOR_DTOR(RecordingSettingsWrap)

//
// IRecordingSettings properties
//

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

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

    HRESULT hrc;

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

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

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

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

    HRESULT hrc;

    try
    {
        

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

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

STDMETHODIMP RecordingSettingsWrap::COMGETTER(Screens)(ComSafeArrayOut(IRecordingScreenSettings *, aScreens))
{
    LogRelFlow(("{%p} %s: enter aScreens=%p\n", this, "RecordingSettings::getScreens", aScreens));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreens);
        ArrayComTypeOutConverter<IRecordingScreenSettings> TmpScreens(ComSafeArrayOutArg(aScreens));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreens(TmpScreens.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpScreens.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GET_SCREENS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreens=%zu hrc=%Rhrc\n", this, "RecordingSettings::getScreens", ComSafeArraySize(*aScreens), hrc));
    return hrc;
}


//
// IRecordingSettings methods
//

STDMETHODIMP RecordingSettingsWrap::GetScreenSettings(ULONG aScreenId,
                                                      IRecordingScreenSettings **aRecordScreenSettings)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aRecordScreenSettings=%p\n", this, "RecordingSettings::getScreenSettings", aScreenId, aRecordScreenSettings));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecordScreenSettings);


        
        ComTypeOutConverter<IRecordingScreenSettings> TmpRecordScreenSettings(aRecordScreenSettings);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenSettings(aScreenId,
                                    TmpRecordScreenSettings.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 0 /*normal*/, aScreenId, (void *)TmpRecordScreenSettings.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_RECORDINGSETTINGS_GETSCREENSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aRecordScreenSettings=%p hrc=%Rhrc\n", this, "RecordingSettings::getScreenSettings", *aRecordScreenSettings, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(RecordingSettingsWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(RecordingSettingsWrap, IRecordingSettings)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "RecordingSettingsWrap.cpp"


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_PCIDEVICEATTACHMENT

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

DEFINE_EMPTY_CTOR_DTOR(PCIDeviceAttachmentWrap)

//
// IPCIDeviceAttachment properties
//

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

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

    HRESULT hrc;

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

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

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(IsPhysicalDevice)(BOOL *aIsPhysicalDevice)
{
    LogRelFlow(("{%p} %s: enter aIsPhysicalDevice=%p\n", this, "PCIDeviceAttachment::getIsPhysicalDevice", aIsPhysicalDevice));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aIsPhysicalDevice=%RTbool hrc=%Rhrc\n", this, "PCIDeviceAttachment::getIsPhysicalDevice", *aIsPhysicalDevice, hrc));
    return hrc;
}

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(HostAddress)(LONG *aHostAddress)
{
    LogRelFlow(("{%p} %s: enter aHostAddress=%p\n", this, "PCIDeviceAttachment::getHostAddress", aHostAddress));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostAddress);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostAddress(aHostAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 0 /*normal*/,*aHostAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,*aHostAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_HOSTADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,*aHostAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostAddress=%RI32 hrc=%Rhrc\n", this, "PCIDeviceAttachment::getHostAddress", *aHostAddress, hrc));
    return hrc;
}

STDMETHODIMP PCIDeviceAttachmentWrap::COMGETTER(GuestAddress)(LONG *aGuestAddress)
{
    LogRelFlow(("{%p} %s: enter aGuestAddress=%p\n", this, "PCIDeviceAttachment::getGuestAddress", aGuestAddress));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestAddress);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestAddress(aGuestAddress);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 0 /*normal*/,*aGuestAddress);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,*aGuestAddress);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PCIDEVICEATTACHMENT_GET_GUESTADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,*aGuestAddress);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestAddress=%RI32 hrc=%Rhrc\n", this, "PCIDeviceAttachment::getGuestAddress", *aGuestAddress, hrc));
    return hrc;
}


//
// IPCIDeviceAttachment methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PCIDeviceAttachmentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PCIDeviceAttachmentWrap, IPCIDeviceAttachment)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PCIDeviceAttachmentWrap.cpp"


// ##### BEGINFILE "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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", 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.rc();
        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.rc();
        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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", 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.rc();
        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", 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.rc();
        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", 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.rc();
        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", *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.rc();
        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", *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.rc();
        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", 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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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.rc();
        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.rc();
        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.rc();
        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.rc();
        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", *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.rc();
        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", *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.rc();
        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", 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.rc();
        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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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.rc();
        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", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP ConsoleWrap::AddDiskEncryptionPassword(IN_BSTR aId,
                                                    IN_BSTR aPassword,
                                                    BOOL aClearOnSuspend)
{
    LogRelFlow(("{%p} %s:enter aId=%ls aPassword=%ls aClearOnSuspend=%RTbool\n", this, "Console::addDiskEncryptionPassword", 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_ADDDISKENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str(), TmpPassword.str().c_str(), aClearOnSuspend != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addDiskEncryptionPassword(TmpId.str(),
                                            TmpPassword.str(),
                                            aClearOnSuspend != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDDISKENCRYPTIONPASSWORD_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_ADDDISKENCRYPTIONPASSWORD_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_ADDDISKENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aClearOnSuspend != FALSE);
#endif
    }

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

STDMETHODIMP ConsoleWrap::AddDiskEncryptionPasswords(ComSafeArrayIn(IN_BSTR, aIds),
                                                     ComSafeArrayIn(IN_BSTR, aPasswords),
                                                     BOOL aClearOnSuspend)
{
    LogRelFlow(("{%p} %s:enter aIds=%zu aPasswords=%zu aClearOnSuspend=%RTbool\n", this, "Console::addDiskEncryptionPasswords", 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_ADDDISKENCRYPTIONPASSWORDS_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.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addDiskEncryptionPasswords(TmpIds.array(),
                                             TmpPasswords.array(),
                                             aClearOnSuspend != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_ADDDISKENCRYPTIONPASSWORDS_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_ADDDISKENCRYPTIONPASSWORDS_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_ADDDISKENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, aClearOnSuspend != FALSE);
#endif
    }

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

STDMETHODIMP ConsoleWrap::RemoveDiskEncryptionPassword(IN_BSTR aId)
{
    LogRelFlow(("{%p} %s:enter aId=%ls\n", this, "Console::removeDiskEncryptionPassword", 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_REMOVEDISKENCRYPTIONPASSWORD_ENTER(this, TmpId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeDiskEncryptionPassword(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEDISKENCRYPTIONPASSWORD_RETURN(this, hrc, 0 /*normal*/, TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEDISKENCRYPTIONPASSWORD_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_REMOVEDISKENCRYPTIONPASSWORD_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

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

STDMETHODIMP ConsoleWrap::ClearAllDiskEncryptionPasswords()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Console::clearAllDiskEncryptionPasswords"));

    // Clear error info, to make in-process calls 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_CLEARALLDISKENCRYPTIONPASSWORDS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = clearAllDiskEncryptionPasswords();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLDISKENCRYPTIONPASSWORDS_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLDISKENCRYPTIONPASSWORDS_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CONSOLE_CLEARALLDISKENCRYPTIONPASSWORDS_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Console::clearAllDiskEncryptionPasswords", 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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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.rc();
        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.rc();
        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 "HostUpdateWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IHostUpdate.
 *
 * 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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_HOSTUPDATE

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

DEFINE_EMPTY_CTOR_DTOR(HostUpdateWrap)

//
// IHostUpdate properties
//

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute1IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute2IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute3IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute4IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute5IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute6IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute7IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute8IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute9IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute10IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute11IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute12IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute13IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute14IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute15IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute16IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute17IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute18IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute19IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute20IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute21IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute22IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute23IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::COMGETTER(InternalAndReservedAttribute24IHostUpdate)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IHostUpdate methods
//

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod1IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod2IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod3IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod4IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod5IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod6IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod7IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod8IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod9IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod10IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod11IHostUpdate()
{
    return E_NOTIMPL;
}

STDMETHODIMP HostUpdateWrap::InternalAndReservedMethod12IHostUpdate()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(HostUpdateWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostUpdateWrap, IHostUpdate)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "HostUpdateWrap.cpp"


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

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTOSTYPE

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

DEFINE_EMPTY_CTOR_DTOR(GuestOSTypeWrap)

//
// IGuestOSType properties
//

STDMETHODIMP GuestOSTypeWrap::COMGETTER(FamilyId)(BSTR *aFamilyId)
{
    LogRelFlow(("{%p} %s: enter aFamilyId=%p\n", this, "GuestOSType::getFamilyId", aFamilyId));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFamilyId);
        BSTROutConverter TmpFamilyId(aFamilyId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFamilyId(TmpFamilyId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 0 /*normal*/,TmpFamilyId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFamilyId=%ls hrc=%Rhrc\n", this, "GuestOSType::getFamilyId", *aFamilyId, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(FamilyDescription)(BSTR *aFamilyDescription)
{
    LogRelFlow(("{%p} %s: enter aFamilyDescription=%p\n", this, "GuestOSType::getFamilyDescription", aFamilyDescription));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFamilyDescription);
        BSTROutConverter TmpFamilyDescription(aFamilyDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFamilyDescription(TmpFamilyDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpFamilyDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_FAMILYDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFamilyDescription=%ls hrc=%Rhrc\n", this, "GuestOSType::getFamilyDescription", *aFamilyDescription, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestOSType::getId", aId));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        BSTROutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

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

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "GuestOSType::getDescription", aDescription));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "GuestOSType::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Is64Bit)(BOOL *aIs64Bit)
{
    LogRelFlow(("{%p} %s: enter aIs64Bit=%p\n", this, "GuestOSType::getIs64Bit", aIs64Bit));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aIs64Bit=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getIs64Bit", *aIs64Bit, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedIOAPIC)(BOOL *aRecommendedIOAPIC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedIOAPIC=%p\n", this, "GuestOSType::getRecommendedIOAPIC", aRecommendedIOAPIC));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aRecommendedIOAPIC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedIOAPIC", *aRecommendedIOAPIC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedVirtEx)(BOOL *aRecommendedVirtEx)
{
    LogRelFlow(("{%p} %s: enter aRecommendedVirtEx=%p\n", this, "GuestOSType::getRecommendedVirtEx", aRecommendedVirtEx));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aRecommendedVirtEx=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedVirtEx", *aRecommendedVirtEx, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedRAM)(ULONG *aRecommendedRAM)
{
    LogRelFlow(("{%p} %s: enter aRecommendedRAM=%p\n", this, "GuestOSType::getRecommendedRAM", aRecommendedRAM));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedRAM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedRAM(aRecommendedRAM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 0 /*normal*/,*aRecommendedRAM);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedRAM);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRAM_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedRAM);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedRAM=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedRAM", *aRecommendedRAM, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedGraphicsController)(GraphicsControllerType_T *aRecommendedGraphicsController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedGraphicsController=%p\n", this, "GuestOSType::getRecommendedGraphicsController", aRecommendedGraphicsController));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedGraphicsController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedGraphicsController(aRecommendedGraphicsController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedGraphicsController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedGraphicsController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDGRAPHICSCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedGraphicsController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedGraphicsController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedGraphicsController", *aRecommendedGraphicsController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedVRAM)(ULONG *aRecommendedVRAM)
{
    LogRelFlow(("{%p} %s: enter aRecommendedVRAM=%p\n", this, "GuestOSType::getRecommendedVRAM", aRecommendedVRAM));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedVRAM);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedVRAM(aRecommendedVRAM);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 0 /*normal*/,*aRecommendedVRAM);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedVRAM);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDVRAM_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedVRAM);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedVRAM=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedVRAM", *aRecommendedVRAM, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Recommended2DVideoAcceleration)(BOOL *aRecommended2DVideoAcceleration)
{
    LogRelFlow(("{%p} %s: enter aRecommended2DVideoAcceleration=%p\n", this, "GuestOSType::getRecommended2DVideoAcceleration", aRecommended2DVideoAcceleration));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aRecommended2DVideoAcceleration=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommended2DVideoAcceleration", *aRecommended2DVideoAcceleration, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(Recommended3DAcceleration)(BOOL *aRecommended3DAcceleration)
{
    LogRelFlow(("{%p} %s: enter aRecommended3DAcceleration=%p\n", this, "GuestOSType::getRecommended3DAcceleration", aRecommended3DAcceleration));

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

    HRESULT hrc;

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

    LogRelFlow(("{%p} %s: leave *aRecommended3DAcceleration=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommended3DAcceleration", *aRecommended3DAcceleration, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDD)(LONG64 *aRecommendedHDD)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDD=%p\n", this, "GuestOSType::getRecommendedHDD", aRecommendedHDD));

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

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDD);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDD(aRecommendedHDD);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDD);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDD);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDD_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDD);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDD=%RI64 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDD", *aRecommendedHDD, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(AdapterType)(NetworkAdapterType_T *aAdapterType)
{
    LogRelFlow(("{%p} %s: enter aAdapterType=%p\n", this, "GuestOSType::getAdapterType", aAdapterType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAdapterType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAdapterType(aAdapterType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 0 /*normal*/,*aAdapterType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAdapterType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_ADAPTERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAdapterType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAdapterType=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getAdapterType", *aAdapterType, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedPAE)(BOOL *aRecommendedPAE)
{
    LogRelFlow(("{%p} %s: enter aRecommendedPAE=%p\n", this, "GuestOSType::getRecommendedPAE", aRecommendedPAE));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedPAE);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedPAE(aRecommendedPAE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedPAE != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedPAE != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDPAE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedPAE != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedPAE=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedPAE", *aRecommendedPAE, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedDVDStorageController)(StorageControllerType_T *aRecommendedDVDStorageController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedDVDStorageController=%p\n", this, "GuestOSType::getRecommendedDVDStorageController", aRecommendedDVDStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedDVDStorageController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedDVDStorageController(aRecommendedDVDStorageController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedDVDStorageController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedDVDStorageController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedDVDStorageController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedDVDStorageController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedDVDStorageController", *aRecommendedDVDStorageController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedDVDStorageBus)(StorageBus_T *aRecommendedDVDStorageBus)
{
    LogRelFlow(("{%p} %s: enter aRecommendedDVDStorageBus=%p\n", this, "GuestOSType::getRecommendedDVDStorageBus", aRecommendedDVDStorageBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedDVDStorageBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedDVDStorageBus(aRecommendedDVDStorageBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/,*aRecommendedDVDStorageBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedDVDStorageBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDDVDSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedDVDStorageBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedDVDStorageBus=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedDVDStorageBus", *aRecommendedDVDStorageBus, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDStorageController)(StorageControllerType_T *aRecommendedHDStorageController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDStorageController=%p\n", this, "GuestOSType::getRecommendedHDStorageController", aRecommendedHDStorageController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDStorageController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDStorageController(aRecommendedHDStorageController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDStorageController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDStorageController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGECONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDStorageController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDStorageController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDStorageController", *aRecommendedHDStorageController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHDStorageBus)(StorageBus_T *aRecommendedHDStorageBus)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHDStorageBus=%p\n", this, "GuestOSType::getRecommendedHDStorageBus", aRecommendedHDStorageBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHDStorageBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHDStorageBus(aRecommendedHDStorageBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHDStorageBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHDStorageBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHDSTORAGEBUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHDStorageBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHDStorageBus=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHDStorageBus", *aRecommendedHDStorageBus, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedFirmware)(FirmwareType_T *aRecommendedFirmware)
{
    LogRelFlow(("{%p} %s: enter aRecommendedFirmware=%p\n", this, "GuestOSType::getRecommendedFirmware", aRecommendedFirmware));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedFirmware);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedFirmware(aRecommendedFirmware);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 0 /*normal*/,*aRecommendedFirmware);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedFirmware);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFIRMWARE_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedFirmware);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedFirmware=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedFirmware", *aRecommendedFirmware, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSBHID)(BOOL *aRecommendedUSBHID)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSBHID=%p\n", this, "GuestOSType::getRecommendedUSBHID", aRecommendedUSBHID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSBHID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSBHID(aRecommendedUSBHID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSBHID != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSBHID != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBHID_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSBHID != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSBHID=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSBHID", *aRecommendedUSBHID, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedHPET)(BOOL *aRecommendedHPET)
{
    LogRelFlow(("{%p} %s: enter aRecommendedHPET=%p\n", this, "GuestOSType::getRecommendedHPET", aRecommendedHPET));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedHPET);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedHPET(aRecommendedHPET);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedHPET != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedHPET != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDHPET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedHPET != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedHPET=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedHPET", *aRecommendedHPET, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSBTablet)(BOOL *aRecommendedUSBTablet)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSBTablet=%p\n", this, "GuestOSType::getRecommendedUSBTablet", aRecommendedUSBTablet));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSBTablet);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSBTablet(aRecommendedUSBTablet);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSBTablet != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSBTablet != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSBTABLET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSBTablet != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSBTablet=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSBTablet", *aRecommendedUSBTablet, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedRTCUseUTC)(BOOL *aRecommendedRTCUseUTC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedRTCUseUTC=%p\n", this, "GuestOSType::getRecommendedRTCUseUTC", aRecommendedRTCUseUTC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedRTCUseUTC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedRTCUseUTC(aRecommendedRTCUseUTC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDRTCUSEUTC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedRTCUseUTC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedRTCUseUTC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedRTCUseUTC", *aRecommendedRTCUseUTC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedChipset)(ChipsetType_T *aRecommendedChipset)
{
    LogRelFlow(("{%p} %s: enter aRecommendedChipset=%p\n", this, "GuestOSType::getRecommendedChipset", aRecommendedChipset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedChipset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedChipset(aRecommendedChipset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedChipset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedChipset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCHIPSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedChipset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedChipset=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedChipset", *aRecommendedChipset, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedAudioController)(AudioControllerType_T *aRecommendedAudioController)
{
    LogRelFlow(("{%p} %s: enter aRecommendedAudioController=%p\n", this, "GuestOSType::getRecommendedAudioController", aRecommendedAudioController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedAudioController);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedAudioController(aRecommendedAudioController);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 0 /*normal*/,*aRecommendedAudioController);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedAudioController);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedAudioController);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedAudioController=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedAudioController", *aRecommendedAudioController, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedAudioCodec)(AudioCodecType_T *aRecommendedAudioCodec)
{
    LogRelFlow(("{%p} %s: enter aRecommendedAudioCodec=%p\n", this, "GuestOSType::getRecommendedAudioCodec", aRecommendedAudioCodec));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedAudioCodec);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedAudioCodec(aRecommendedAudioCodec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedAudioCodec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedAudioCodec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDAUDIOCODEC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedAudioCodec);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedAudioCodec=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedAudioCodec", *aRecommendedAudioCodec, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedFloppy)(BOOL *aRecommendedFloppy)
{
    LogRelFlow(("{%p} %s: enter aRecommendedFloppy=%p\n", this, "GuestOSType::getRecommendedFloppy", aRecommendedFloppy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedFloppy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedFloppy(aRecommendedFloppy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 0 /*normal*/,*aRecommendedFloppy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedFloppy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDFLOPPY_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedFloppy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedFloppy=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedFloppy", *aRecommendedFloppy, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSB)(BOOL *aRecommendedUSB)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSB=%p\n", this, "GuestOSType::getRecommendedUSB", aRecommendedUSB));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSB);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSB(aRecommendedUSB);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSB != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSB != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSB != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSB=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSB", *aRecommendedUSB, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedUSB3)(BOOL *aRecommendedUSB3)
{
    LogRelFlow(("{%p} %s: enter aRecommendedUSB3=%p\n", this, "GuestOSType::getRecommendedUSB3", aRecommendedUSB3));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedUSB3);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedUSB3(aRecommendedUSB3);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 0 /*normal*/,*aRecommendedUSB3 != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedUSB3 != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDUSB3_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedUSB3 != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedUSB3=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedUSB3", *aRecommendedUSB3, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedTFReset)(BOOL *aRecommendedTFReset)
{
    LogRelFlow(("{%p} %s: enter aRecommendedTFReset=%p\n", this, "GuestOSType::getRecommendedTFReset", aRecommendedTFReset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedTFReset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedTFReset(aRecommendedTFReset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 0 /*normal*/,*aRecommendedTFReset != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedTFReset != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDTFRESET_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedTFReset != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedTFReset=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedTFReset", *aRecommendedTFReset, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedX2APIC)(BOOL *aRecommendedX2APIC)
{
    LogRelFlow(("{%p} %s: enter aRecommendedX2APIC=%p\n", this, "GuestOSType::getRecommendedX2APIC", aRecommendedX2APIC));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedX2APIC);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedX2APIC(aRecommendedX2APIC);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 0 /*normal*/,*aRecommendedX2APIC != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedX2APIC != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDX2APIC_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedX2APIC != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedX2APIC=%RTbool hrc=%Rhrc\n", this, "GuestOSType::getRecommendedX2APIC", *aRecommendedX2APIC, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(RecommendedCPUCount)(ULONG *aRecommendedCPUCount)
{
    LogRelFlow(("{%p} %s: enter aRecommendedCPUCount=%p\n", this, "GuestOSType::getRecommendedCPUCount", aRecommendedCPUCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRecommendedCPUCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRecommendedCPUCount(aRecommendedCPUCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 0 /*normal*/,*aRecommendedCPUCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aRecommendedCPUCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTOSTYPE_GET_RECOMMENDEDCPUCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aRecommendedCPUCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRecommendedCPUCount=%RU32 hrc=%Rhrc\n", this, "GuestOSType::getRecommendedCPUCount", *aRecommendedCPUCount, hrc));
    return hrc;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute1IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute2IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute3IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute4IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute5IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute6IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute7IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute8IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute9IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute10IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute11IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute12IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute13IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute14IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestOSTypeWrap::COMGETTER(InternalAndReservedAttribute15IGuestOSType)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuestOSType methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestOSTypeWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestOSTypeWrap, IGuestOSType)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestOSTypeWrap.cpp"


// ##### BEGINFILE "AdditionsFacilityWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IAdditionsFacility.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_ADDITIONSFACILITY

#include "AdditionsFacilityWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(AdditionsFacilityWrap)

//
// IAdditionsFacility properties
//

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(ClassType)(AdditionsFacilityClass_T *aClassType)
{
    LogRelFlow(("{%p} %s: enter aClassType=%p\n", this, "AdditionsFacility::getClassType", aClassType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aClassType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getClassType(aClassType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 0 /*normal*/,*aClassType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aClassType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_CLASSTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aClassType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aClassType=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getClassType", *aClassType, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(LastUpdated)(LONG64 *aLastUpdated)
{
    LogRelFlow(("{%p} %s: enter aLastUpdated=%p\n", this, "AdditionsFacility::getLastUpdated", aLastUpdated));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLastUpdated);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLastUpdated(aLastUpdated);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 0 /*normal*/,*aLastUpdated);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 1 /*hrc exception*/,*aLastUpdated);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_LASTUPDATED_RETURN(this, hrc, 9 /*unhandled exception*/,*aLastUpdated);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLastUpdated=%RI64 hrc=%Rhrc\n", this, "AdditionsFacility::getLastUpdated", *aLastUpdated, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "AdditionsFacility::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "AdditionsFacility::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Status)(AdditionsFacilityStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "AdditionsFacility::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getStatus", *aStatus, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(Type)(AdditionsFacilityType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "AdditionsFacility::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_ADDITIONSFACILITY_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "AdditionsFacility::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(InternalAndReservedAttribute1IAdditionsFacility)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP AdditionsFacilityWrap::COMGETTER(InternalAndReservedAttribute2IAdditionsFacility)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IAdditionsFacility methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(AdditionsFacilityWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AdditionsFacilityWrap, IAdditionsFacility)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "AdditionsFacilityWrap.cpp"


// ##### BEGINFILE "DnDSourceWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDnDSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DNDSOURCE

#include "DnDSourceWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DnDSourceWrap)

//
// IDnDBase properties
//

STDMETHODIMP DnDSourceWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "DnDSource::getFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "DnDSource::getFormats", ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(ProtocolVersion)(ULONG *aProtocolVersion)
{
    LogRelFlow(("{%p} %s: enter aProtocolVersion=%p\n", this, "DnDSource::getProtocolVersion", aProtocolVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProtocolVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_PROTOCOLVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProtocolVersion(aProtocolVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_PROTOCOLVERSION_RETURN(this, hrc, 0 /*normal*/,*aProtocolVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_PROTOCOLVERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aProtocolVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_GET_PROTOCOLVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aProtocolVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProtocolVersion=%RU32 hrc=%Rhrc\n", this, "DnDSource::getProtocolVersion", *aProtocolVersion, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDSource properties
//

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute1IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDSourceWrap::COMGETTER(InternalAndReservedAttribute2IDnDSource)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDnDBase methods
//

STDMETHODIMP DnDSourceWrap::IsFormatSupported(IN_BSTR aFormat,
                                              BOOL *aSupported)
{
    LogRelFlow(("{%p} %s:enter aFormat=%ls aSupported=%p\n", this, "DnDSource::isFormatSupported", aFormat, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        BSTRInConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_ENTER(this, TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFormatSupported(TmpFormat.str(),
                                    aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "DnDSource::isFormatSupported", *aSupported, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s:enter aFormats=%zu\n", this, "DnDSource::addFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDSource::addFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s:enter aFormats=%zu\n", this, "DnDSource::removeFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDSource::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDSource methods
//

STDMETHODIMP DnDSourceWrap::DragIsPending(ULONG aScreenId,
                                          ComSafeArrayOut(BSTR, aFormats),
                                          ComSafeArrayOut(DnDAction_T, aAllowedActions),
                                          DnDAction_T *aDefaultAction)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aFormats=%p aAllowedActions=%p aDefaultAction=%p\n", this, "DnDSource::dragIsPending", aScreenId, aFormats, aAllowedActions, aDefaultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        CheckComArgOutPointerValidThrow(aAllowedActions);
        CheckComArgOutPointerValidThrow(aDefaultAction);


        
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
        ArrayOutConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayOutArg(aAllowedActions));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = dragIsPending(aScreenId,
                                TmpFormats.array(),
                                TmpAllowedActions.array(),
                                aDefaultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 0 /*normal*/, aScreenId, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, *aDefaultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0, 0, 0, 0, *aDefaultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DRAGISPENDING_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0, 0, 0, *aDefaultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu *aAllowedActions=%zu aDefaultAction=%RU32 hrc=%Rhrc\n", this, "DnDSource::dragIsPending", ComSafeArraySize(*aFormats), ComSafeArraySize(*aAllowedActions), *aDefaultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::Drop(IN_BSTR aFormat,
                                 DnDAction_T aAction,
                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aFormat=%ls aAction=%RU32 aProgress=%p\n", this, "DnDSource::drop", aFormat, aAction, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFormat(aFormat);
        
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_ENTER(this, TmpFormat.str().c_str(), aAction);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = drop(TmpFormat.str(),
                       aAction,
                       TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), aAction, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAction, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_DROP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAction, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "DnDSource::drop", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::ReceiveData(ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aData=%p\n", this, "DnDSource::receiveData", aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = receiveData(TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDSOURCE_RECEIVEDATA_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "DnDSource::receiveData", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP DnDSourceWrap::InternalAndReservedMethod1IDnDSource()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DnDSourceWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DnDSourceWrap, IDnDSource, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DnDSourceWrap.cpp"


// ##### BEGINFILE "DnDTargetWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDnDTarget.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DNDTARGET

#include "DnDTargetWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DnDTargetWrap)

//
// IDnDBase properties
//

STDMETHODIMP DnDTargetWrap::COMGETTER(Formats)(ComSafeArrayOut(BSTR, aFormats))
{
    LogRelFlow(("{%p} %s: enter aFormats=%p\n", this, "DnDTarget::getFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormats);
        ArrayBSTROutConverter TmpFormats(ComSafeArrayOutArg(aFormats));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_FORMATS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormats=%zu hrc=%Rhrc\n", this, "DnDTarget::getFormats", ComSafeArraySize(*aFormats), hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(ProtocolVersion)(ULONG *aProtocolVersion)
{
    LogRelFlow(("{%p} %s: enter aProtocolVersion=%p\n", this, "DnDTarget::getProtocolVersion", aProtocolVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProtocolVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_PROTOCOLVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProtocolVersion(aProtocolVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_PROTOCOLVERSION_RETURN(this, hrc, 0 /*normal*/,*aProtocolVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_PROTOCOLVERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aProtocolVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_GET_PROTOCOLVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aProtocolVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProtocolVersion=%RU32 hrc=%Rhrc\n", this, "DnDTarget::getProtocolVersion", *aProtocolVersion, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IDnDTarget properties
//

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute1IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DnDTargetWrap::COMGETTER(InternalAndReservedAttribute2IDnDTarget)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDnDBase methods
//

STDMETHODIMP DnDTargetWrap::IsFormatSupported(IN_BSTR aFormat,
                                              BOOL *aSupported)
{
    LogRelFlow(("{%p} %s:enter aFormat=%ls aSupported=%p\n", this, "DnDTarget::isFormatSupported", aFormat, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        BSTRInConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_ENTER(this, TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = isFormatSupported(TmpFormat.str(),
                                    aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ISFORMATSUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "DnDTarget::isFormatSupported", *aSupported, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::AddFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s:enter aFormats=%zu\n", this, "DnDTarget::addFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ADDFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::addFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::RemoveFormats(ComSafeArrayIn(IN_BSTR, aFormats))
{
    LogRelFlow(("{%p} %s:enter aFormats=%zu\n", this, "DnDTarget::removeFormats", aFormats));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_ENTER(this, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeFormats(TmpFormats.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_REMOVEFORMATS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::removeFormats", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::InternalAndReservedMethod1IDnDBase()
{
    return E_NOTIMPL;
}

//
// IDnDTarget methods
//

STDMETHODIMP DnDTargetWrap::Enter(ULONG aScreenId,
                                  ULONG aY,
                                  ULONG aX,
                                  DnDAction_T aDefaultAction,
                                  ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                  ComSafeArrayIn(IN_BSTR, aFormats),
                                  DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aY=%RU32 aX=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aResultAction=%p\n", this, "DnDTarget::enter", aScreenId, aY, aX, aDefaultAction, aAllowedActions, aFormats, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_ENTER(this, aScreenId, aY, aX, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = enter(aScreenId,
                        aY,
                        aX,
                        aDefaultAction,
                        TmpAllowedActions.array(),
                        TmpFormats.array(),
                        aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 0 /*normal*/, aScreenId, aY, aX, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aY, aX, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_ENTER_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aY, aX, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::enter", *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Move(ULONG aScreenId,
                                 ULONG aX,
                                 ULONG aY,
                                 DnDAction_T aDefaultAction,
                                 ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                 ComSafeArrayIn(IN_BSTR, aFormats),
                                 DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aX=%RU32 aY=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aResultAction=%p\n", this, "DnDTarget::move", aScreenId, aX, aY, aDefaultAction, aAllowedActions, aFormats, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_ENTER(this, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = move(aScreenId,
                       aX,
                       aY,
                       aDefaultAction,
                       TmpAllowedActions.array(),
                       TmpFormats.array(),
                       aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_MOVE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::move", *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Leave(ULONG aScreenId)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32\n", this, "DnDTarget::leave", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_ENTER(this, aScreenId);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = leave(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 0 /*normal*/, aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_LEAVE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "DnDTarget::leave", hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Drop(ULONG aScreenId,
                                 ULONG aX,
                                 ULONG aY,
                                 DnDAction_T aDefaultAction,
                                 ComSafeArrayIn(DnDAction_T, aAllowedActions),
                                 ComSafeArrayIn(IN_BSTR, aFormats),
                                 BSTR *aFormat,
                                 DnDAction_T *aResultAction)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aX=%RU32 aY=%RU32 aDefaultAction=%RU32 aAllowedActions=%zu aFormats=%zu aFormat=%p aResultAction=%p\n", this, "DnDTarget::drop", aScreenId, aX, aY, aDefaultAction, aAllowedActions, aFormats, aFormat, aResultAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFormat);
        CheckComArgOutPointerValidThrow(aResultAction);


        
        
        
        
        ArrayInConverter<DnDAction_T> TmpAllowedActions(ComSafeArrayInArg(aAllowedActions));
        ArrayBSTRInConverter TmpFormats(ComSafeArrayInArg(aFormats));
        BSTROutConverter TmpFormat(aFormat);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_ENTER(this, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = drop(aScreenId,
                       aX,
                       aY,
                       aDefaultAction,
                       TmpAllowedActions.array(),
                       TmpFormats.array(),
                       TmpFormat.str(),
                       aResultAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 0 /*normal*/, aScreenId, aX, aY, aDefaultAction, (uint32_t)TmpAllowedActions.array().size(), NULL /*for now*/, (uint32_t)TmpFormats.array().size(), NULL /*for now*/, TmpFormat.str().c_str(), *aResultAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, 0, *aResultAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_DROP_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aX, aY, aDefaultAction, 0, 0, 0, 0, 0, *aResultAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFormat=%ls aResultAction=%RU32 hrc=%Rhrc\n", this, "DnDTarget::drop", *aFormat, *aResultAction, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::SendData(ULONG aScreenId,
                                     IN_BSTR aFormat,
                                     ComSafeArrayIn(BYTE, aData),
                                     IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aFormat=%ls aData=%zu aProgress=%p\n", this, "DnDTarget::sendData", aScreenId, aFormat, aData, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        
        BSTRInConverter TmpFormat(aFormat);
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_ENTER(this, aScreenId, TmpFormat.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = sendData(aScreenId,
                           TmpFormat.str(),
                           TmpData.array(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 0 /*normal*/, aScreenId, TmpFormat.str().c_str(), (uint32_t)TmpData.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_SENDDATA_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "DnDTarget::sendData", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::Cancel(BOOL *aVeto)
{
    LogRelFlow(("{%p} %s:enter aVeto=%p\n", this, "DnDTarget::cancel", aVeto));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVeto);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancel(aVeto);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 0 /*normal*/, *aVeto != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 1 /*hrc exception*/, *aVeto != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DNDTARGET_CANCEL_RETURN(this, hrc, 9 /*unhandled exception*/, *aVeto != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aVeto=%RTbool hrc=%Rhrc\n", this, "DnDTarget::cancel", *aVeto, hrc));
    return hrc;
}

STDMETHODIMP DnDTargetWrap::InternalAndReservedMethod1IDnDTarget()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DnDTargetWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(DnDTargetWrap, IDnDTarget, IDnDBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DnDTargetWrap.cpp"


// ##### BEGINFILE "GuestSessionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestSession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTSESSION

#include "GuestSessionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestSessionWrap)

//
// IGuestSession properties
//

STDMETHODIMP GuestSessionWrap::COMGETTER(User)(BSTR *aUser)
{
    LogRelFlow(("{%p} %s: enter aUser=%p\n", this, "GuestSession::getUser", aUser));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUser);
        BSTROutConverter TmpUser(aUser);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUser(TmpUser.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 0 /*normal*/,TmpUser.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUser=%ls hrc=%Rhrc\n", this, "GuestSession::getUser", *aUser, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Domain)(BSTR *aDomain)
{
    LogRelFlow(("{%p} %s: enter aDomain=%p\n", this, "GuestSession::getDomain", aDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDomain);
        BSTROutConverter TmpDomain(aDomain);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDomain(TmpDomain.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 0 /*normal*/,TmpDomain.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDomain=%ls hrc=%Rhrc\n", this, "GuestSession::getDomain", *aDomain, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestSession::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestSession::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestSession::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,*aId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "GuestSession::getId", *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Timeout)(ULONG *aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%p\n", this, "GuestSession::getTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeout=%RU32 hrc=%Rhrc\n", this, "GuestSession::getTimeout", *aTimeout, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(Timeout)(ULONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RU32\n", this, "GuestSession::setTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setTimeout", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(ProtocolVersion)(ULONG *aProtocolVersion)
{
    LogRelFlow(("{%p} %s: enter aProtocolVersion=%p\n", this, "GuestSession::getProtocolVersion", aProtocolVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProtocolVersion);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProtocolVersion(aProtocolVersion);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 0 /*normal*/,*aProtocolVersion);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 1 /*hrc exception*/,*aProtocolVersion);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROTOCOLVERSION_RETURN(this, hrc, 9 /*unhandled exception*/,*aProtocolVersion);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProtocolVersion=%RU32 hrc=%Rhrc\n", this, "GuestSession::getProtocolVersion", *aProtocolVersion, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Status)(GuestSessionStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestSession::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestSession::getStatus", *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EnvironmentChanges)(ComSafeArrayOut(BSTR, aEnvironmentChanges))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentChanges=%p\n", this, "GuestSession::getEnvironmentChanges", aEnvironmentChanges));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironmentChanges);
        ArrayBSTROutConverter TmpEnvironmentChanges(ComSafeArrayOutArg(aEnvironmentChanges));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironmentChanges(TmpEnvironmentChanges.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTCHANGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironmentChanges=%zu hrc=%Rhrc\n", this, "GuestSession::getEnvironmentChanges", ComSafeArraySize(*aEnvironmentChanges), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(EnvironmentChanges)(ComSafeArrayIn(IN_BSTR, aEnvironmentChanges))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentChanges=%zu\n", this, "GuestSession::setEnvironmentChanges", ComSafeArraySize(aEnvironmentChanges)));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_ENTER(this, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnvironmentChanges(TmpEnvironmentChanges.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_ENVIRONMENTCHANGES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setEnvironmentChanges", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EnvironmentBase)(ComSafeArrayOut(BSTR, aEnvironmentBase))
{
    LogRelFlow(("{%p} %s: enter aEnvironmentBase=%p\n", this, "GuestSession::getEnvironmentBase", aEnvironmentBase));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironmentBase);
        ArrayBSTROutConverter TmpEnvironmentBase(ComSafeArrayOutArg(aEnvironmentBase));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironmentBase(TmpEnvironmentBase.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironmentBase.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_ENVIRONMENTBASE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironmentBase=%zu hrc=%Rhrc\n", this, "GuestSession::getEnvironmentBase", ComSafeArraySize(*aEnvironmentBase), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Processes)(ComSafeArrayOut(IGuestProcess *, aProcesses))
{
    LogRelFlow(("{%p} %s: enter aProcesses=%p\n", this, "GuestSession::getProcesses", aProcesses));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProcesses);
        ArrayComTypeOutConverter<IGuestProcess> TmpProcesses(ComSafeArrayOutArg(aProcesses));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getProcesses(TmpProcesses.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpProcesses.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PROCESSES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aProcesses=%zu hrc=%Rhrc\n", this, "GuestSession::getProcesses", ComSafeArraySize(*aProcesses), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(PathStyle)(PathStyle_T *aPathStyle)
{
    LogRelFlow(("{%p} %s: enter aPathStyle=%p\n", this, "GuestSession::getPathStyle", aPathStyle));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPathStyle);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPathStyle(aPathStyle);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 0 /*normal*/,*aPathStyle);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 1 /*hrc exception*/,*aPathStyle);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_PATHSTYLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aPathStyle);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPathStyle=%RU32 hrc=%Rhrc\n", this, "GuestSession::getPathStyle", *aPathStyle, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(CurrentDirectory)(BSTR *aCurrentDirectory)
{
    LogRelFlow(("{%p} %s: enter aCurrentDirectory=%p\n", this, "GuestSession::getCurrentDirectory", aCurrentDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCurrentDirectory);
        BSTROutConverter TmpCurrentDirectory(aCurrentDirectory);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCurrentDirectory(TmpCurrentDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 0 /*normal*/,TmpCurrentDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_CURRENTDIRECTORY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCurrentDirectory=%ls hrc=%Rhrc\n", this, "GuestSession::getCurrentDirectory", *aCurrentDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMSETTER(CurrentDirectory)(IN_BSTR aCurrentDirectory)
{
    LogRelFlow(("{%p} %s: enter aCurrentDirectory=%ls\n", this, "GuestSession::setCurrentDirectory", aCurrentDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpCurrentDirectory(aCurrentDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_ENTER(this, TmpCurrentDirectory.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCurrentDirectory(TmpCurrentDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 0 /*normal*/,TmpCurrentDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SET_CURRENTDIRECTORY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::setCurrentDirectory", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(UserHome)(BSTR *aUserHome)
{
    LogRelFlow(("{%p} %s: enter aUserHome=%p\n", this, "GuestSession::getUserHome", aUserHome));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserHome);
        BSTROutConverter TmpUserHome(aUserHome);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserHome(TmpUserHome.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 0 /*normal*/,TmpUserHome.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERHOME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserHome=%ls hrc=%Rhrc\n", this, "GuestSession::getUserHome", *aUserHome, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(UserDocuments)(BSTR *aUserDocuments)
{
    LogRelFlow(("{%p} %s: enter aUserDocuments=%p\n", this, "GuestSession::getUserDocuments", aUserDocuments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserDocuments);
        BSTROutConverter TmpUserDocuments(aUserDocuments);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserDocuments(TmpUserDocuments.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 0 /*normal*/,TmpUserDocuments.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_USERDOCUMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserDocuments=%ls hrc=%Rhrc\n", this, "GuestSession::getUserDocuments", *aUserDocuments, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Directories)(ComSafeArrayOut(IGuestDirectory *, aDirectories))
{
    LogRelFlow(("{%p} %s: enter aDirectories=%p\n", this, "GuestSession::getDirectories", aDirectories));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectories);
        ArrayComTypeOutConverter<IGuestDirectory> TmpDirectories(ComSafeArrayOutArg(aDirectories));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDirectories(TmpDirectories.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpDirectories.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_DIRECTORIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectories=%zu hrc=%Rhrc\n", this, "GuestSession::getDirectories", ComSafeArraySize(*aDirectories), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(Files)(ComSafeArrayOut(IGuestFile *, aFiles))
{
    LogRelFlow(("{%p} %s: enter aFiles=%p\n", this, "GuestSession::getFiles", aFiles));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFiles);
        ArrayComTypeOutConverter<IGuestFile> TmpFiles(ComSafeArrayOutArg(aFiles));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFiles(TmpFiles.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpFiles.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_FILES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFiles=%zu hrc=%Rhrc\n", this, "GuestSession::getFiles", ComSafeArraySize(*aFiles), hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestSession::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestSession::getEventSource", *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute1IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute2IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute3IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute4IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute5IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute6IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute7IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute8IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute9IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute10IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute11IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::COMGETTER(InternalAndReservedAttribute12IGuestSession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IGuestSession methods
//

STDMETHODIMP GuestSessionWrap::Close()
{
    LogRelFlow(("{%p} %s:enter\n", this, "GuestSession::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::close", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::CopyFromGuest(ComSafeArrayIn(IN_BSTR, aSources),
                                             ComSafeArrayIn(IN_BSTR, aFilters),
                                             ComSafeArrayIn(IN_BSTR, aFlags),
                                             IN_BSTR aDestination,
                                             IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSources=%zu aFilters=%zu aFlags=%zu aDestination=%ls aProgress=%p\n", this, "GuestSession::copyFromGuest", aSources, aFilters, aFlags, aDestination, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSources(ComSafeArrayInArg(aSources));
        ArrayBSTRInConverter TmpFilters(ComSafeArrayInArg(aFilters));
        ArrayBSTRInConverter TmpFlags(ComSafeArrayInArg(aFlags));
        BSTRInConverter TmpDestination(aDestination);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_ENTER(this, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = copyFromGuest(TmpSources.array(),
                                TmpFilters.array(),
                                TmpFlags.array(),
                                TmpDestination.str(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::copyFromGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::CopyToGuest(ComSafeArrayIn(IN_BSTR, aSources),
                                           ComSafeArrayIn(IN_BSTR, aFilters),
                                           ComSafeArrayIn(IN_BSTR, aFlags),
                                           IN_BSTR aDestination,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSources=%zu aFilters=%zu aFlags=%zu aDestination=%ls aProgress=%p\n", this, "GuestSession::copyToGuest", aSources, aFilters, aFlags, aDestination, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSources(ComSafeArrayInArg(aSources));
        ArrayBSTRInConverter TmpFilters(ComSafeArrayInArg(aFilters));
        ArrayBSTRInConverter TmpFlags(ComSafeArrayInArg(aFlags));
        BSTRInConverter TmpDestination(aDestination);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_ENTER(this, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = copyToGuest(TmpSources.array(),
                              TmpFilters.array(),
                              TmpFlags.array(),
                              TmpDestination.str(),
                              TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSources.array().size(), NULL /*for now*/, (uint32_t)TmpFilters.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_COPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::copyToGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopy(IN_BSTR aSource,
                                             IN_BSTR aDestination,
                                             ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                             IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopy", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopy(TmpSource.str(),
                                TmpDestination.str(),
                                TmpFlags.array(),
                                TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopy", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopyFromGuest(IN_BSTR aSource,
                                                      IN_BSTR aDestination,
                                                      ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                                      IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopyFromGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopyFromGuest(TmpSource.str(),
                                         TmpDestination.str(),
                                         TmpFlags.array(),
                                         TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopyFromGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCopyToGuest(IN_BSTR aSource,
                                                    IN_BSTR aDestination,
                                                    ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                                    IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryCopyToGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<DirectoryCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCopyToGuest(TmpSource.str(),
                                       TmpDestination.str(),
                                       TmpFlags.array(),
                                       TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCOPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryCopyToGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCreate(IN_BSTR aPath,
                                               ULONG aMode,
                                               ComSafeArrayIn(DirectoryCreateFlag_T, aFlags))
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aMode=%RU32 aFlags=%zu\n", this, "GuestSession::directoryCreate", aPath, aMode, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);
        
        ArrayInConverter<DirectoryCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_ENTER(this, TmpPath.str().c_str(), aMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCreate(TmpPath.str(),
                                  aMode,
                                  TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::directoryCreate", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryCreateTemp(IN_BSTR aTemplateName,
                                                   ULONG aMode,
                                                   IN_BSTR aPath,
                                                   BOOL aSecure,
                                                   BSTR *aDirectory)
{
    LogRelFlow(("{%p} %s:enter aTemplateName=%ls aMode=%RU32 aPath=%ls aSecure=%RTbool aDirectory=%p\n", this, "GuestSession::directoryCreateTemp", aTemplateName, aMode, aPath, aSecure, aDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectory);


        BSTRInConverter TmpTemplateName(aTemplateName);
        
        BSTRInConverter TmpPath(aPath);
        
        BSTROutConverter TmpDirectory(aDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_ENTER(this, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryCreateTemp(TmpTemplateName.str(),
                                      aMode,
                                      TmpPath.str(),
                                      aSecure != FALSE,
                                      TmpDirectory.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 0 /*normal*/, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE, TmpDirectory.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYCREATETEMP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDirectory=%ls hrc=%Rhrc\n", this, "GuestSession::directoryCreateTemp", *aDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryExists(IN_BSTR aPath,
                                               BOOL aFollowSymlinks,
                                               BOOL *aExists)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::directoryExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryExists(TmpPath.str(),
                                  aFollowSymlinks != FALSE,
                                  aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::directoryExists", *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryOpen(IN_BSTR aPath,
                                             IN_BSTR aFilter,
                                             ComSafeArrayIn(DirectoryOpenFlag_T, aFlags),
                                             IGuestDirectory **aDirectory)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFilter=%ls aFlags=%zu aDirectory=%p\n", this, "GuestSession::directoryOpen", aPath, aFilter, aFlags, aDirectory));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectory);


        BSTRInConverter TmpPath(aPath);
        BSTRInConverter TmpFilter(aFilter);
        ArrayInConverter<DirectoryOpenFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IGuestDirectory> TmpDirectory(aDirectory);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_ENTER(this, TmpPath.str().c_str(), TmpFilter.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryOpen(TmpPath.str(),
                                TmpFilter.str(),
                                TmpFlags.array(),
                                TmpDirectory.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), TmpFilter.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpDirectory.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYOPEN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aDirectory=%p hrc=%Rhrc\n", this, "GuestSession::directoryOpen", *aDirectory, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryRemove(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls\n", this, "GuestSession::directoryRemove", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryRemove(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::directoryRemove", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::DirectoryRemoveRecursive(IN_BSTR aPath,
                                                        ComSafeArrayIn(DirectoryRemoveRecFlag_T, aFlags),
                                                        IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::directoryRemoveRecursive", aPath, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpPath(aPath);
        ArrayInConverter<DirectoryRemoveRecFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_ENTER(this, TmpPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = directoryRemoveRecursive(TmpPath.str(),
                                           TmpFlags.array(),
                                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_DIRECTORYREMOVERECURSIVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::directoryRemoveRecursive", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentScheduleSet(IN_BSTR aName,
                                                      IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aValue=%ls\n", this, "GuestSession::environmentScheduleSet", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentScheduleSet(TmpName.str(),
                                         TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULESET_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::environmentScheduleSet", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentScheduleUnset(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s:enter aName=%ls\n", this, "GuestSession::environmentScheduleUnset", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentScheduleUnset(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTSCHEDULEUNSET_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::environmentScheduleUnset", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentGetBaseVariable(IN_BSTR aName,
                                                          BSTR *aValue)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aValue=%p\n", this, "GuestSession::environmentGetBaseVariable", aName, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpName(aName);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentGetBaseVariable(TmpName.str(),
                                             TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTGETBASEVARIABLE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "GuestSession::environmentGetBaseVariable", *aValue, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::EnvironmentDoesBaseVariableExist(IN_BSTR aName,
                                                                BOOL *aExists)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aExists=%p\n", this, "GuestSession::environmentDoesBaseVariableExist", aName, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpName(aName);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = environmentDoesBaseVariableExist(TmpName.str(),
                                                   aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_ENVIRONMENTDOESBASEVARIABLEEXIST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::environmentDoesBaseVariableExist", *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopy(IN_BSTR aSource,
                                        IN_BSTR aDestination,
                                        ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                        IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopy", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopy(TmpSource.str(),
                           TmpDestination.str(),
                           TmpFlags.array(),
                           TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopy", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopyFromGuest(IN_BSTR aSource,
                                                 IN_BSTR aDestination,
                                                 ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                                 IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopyFromGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopyFromGuest(TmpSource.str(),
                                    TmpDestination.str(),
                                    TmpFlags.array(),
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYFROMGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopyFromGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCopyToGuest(IN_BSTR aSource,
                                               IN_BSTR aDestination,
                                               ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                               IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fileCopyToGuest", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCopyToGuest(TmpSource.str(),
                                  TmpDestination.str(),
                                  TmpFlags.array(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECOPYTOGUEST_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fileCopyToGuest", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileCreateTemp(IN_BSTR aTemplateName,
                                              ULONG aMode,
                                              IN_BSTR aPath,
                                              BOOL aSecure,
                                              IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s:enter aTemplateName=%ls aMode=%RU32 aPath=%ls aSecure=%RTbool aFile=%p\n", this, "GuestSession::fileCreateTemp", aTemplateName, aMode, aPath, aSecure, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpTemplateName(aTemplateName);
        
        BSTRInConverter TmpPath(aPath);
        
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_ENTER(this, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileCreateTemp(TmpTemplateName.str(),
                                 aMode,
                                 TmpPath.str(),
                                 aSecure != FALSE,
                                 TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 0 /*normal*/, TmpTemplateName.str().c_str(), aMode, TmpPath.str().c_str(), aSecure != FALSE, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILECREATETEMP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode, 0, aSecure != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileCreateTemp", *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileExists(IN_BSTR aPath,
                                          BOOL aFollowSymlinks,
                                          BOOL *aExists)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::fileExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileExists(TmpPath.str(),
                             aFollowSymlinks != FALSE,
                             aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::fileExists", *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileOpen(IN_BSTR aPath,
                                        FileAccessMode_T aAccessMode,
                                        FileOpenAction_T aOpenAction,
                                        ULONG aCreationMode,
                                        IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aAccessMode=%RU32 aOpenAction=%RU32 aCreationMode=%RU32 aFile=%p\n", this, "GuestSession::fileOpen", aPath, aAccessMode, aOpenAction, aCreationMode, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpPath(aPath);
        
        
        
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_ENTER(this, TmpPath.str().c_str(), aAccessMode, aOpenAction, aCreationMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileOpen(TmpPath.str(),
                           aAccessMode,
                           aOpenAction,
                           aCreationMode,
                           TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aAccessMode, aOpenAction, aCreationMode, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAccessMode, aOpenAction, aCreationMode, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPEN_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAccessMode, aOpenAction, aCreationMode, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileOpen", *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileOpenEx(IN_BSTR aPath,
                                          FileAccessMode_T aAccessMode,
                                          FileOpenAction_T aOpenAction,
                                          FileSharingMode_T aSharingMode,
                                          ULONG aCreationMode,
                                          ComSafeArrayIn(FileOpenExFlag_T, aFlags),
                                          IGuestFile **aFile)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aAccessMode=%RU32 aOpenAction=%RU32 aSharingMode=%RU32 aCreationMode=%RU32 aFlags=%zu aFile=%p\n", this, "GuestSession::fileOpenEx", aPath, aAccessMode, aOpenAction, aSharingMode, aCreationMode, aFlags, aFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFile);


        BSTRInConverter TmpPath(aPath);
        
        
        
        
        ArrayInConverter<FileOpenExFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IGuestFile> TmpFile(aFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_ENTER(this, TmpPath.str().c_str(), aAccessMode, aOpenAction, aSharingMode, aCreationMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileOpenEx(TmpPath.str(),
                             aAccessMode,
                             aOpenAction,
                             aSharingMode,
                             aCreationMode,
                             TmpFlags.array(),
                             TmpFile.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aAccessMode, aOpenAction, aSharingMode, aCreationMode, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpFile.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 1 /*hrc exception*/, 0, aAccessMode, aOpenAction, aSharingMode, aCreationMode, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEOPENEX_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aAccessMode, aOpenAction, aSharingMode, aCreationMode, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aFile=%p hrc=%Rhrc\n", this, "GuestSession::fileOpenEx", *aFile, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FileQuerySize(IN_BSTR aPath,
                                             BOOL aFollowSymlinks,
                                             LONG64 *aSize)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aSize=%p\n", this, "GuestSession::fileQuerySize", aPath, aFollowSymlinks, aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSize);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fileQuerySize(TmpPath.str(),
                                aFollowSymlinks != FALSE,
                                aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FILEQUERYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSize=%RI64 hrc=%Rhrc\n", this, "GuestSession::fileQuerySize", *aSize, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjExists(IN_BSTR aPath,
                                           BOOL aFollowSymlinks,
                                           BOOL *aExists)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aExists=%p\n", this, "GuestSession::fsObjExists", aPath, aFollowSymlinks, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpPath(aPath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjExists(TmpPath.str(),
                              aFollowSymlinks != FALSE,
                              aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::fsObjExists", *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjQueryInfo(IN_BSTR aPath,
                                              BOOL aFollowSymlinks,
                                              IGuestFsObjInfo **aInfo)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aInfo=%p\n", this, "GuestSession::fsObjQueryInfo", aPath, aFollowSymlinks, aInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInfo);


        BSTRInConverter TmpPath(aPath);
        
        ComTypeOutConverter<IGuestFsObjInfo> TmpInfo(aInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjQueryInfo(TmpPath.str(),
                                 aFollowSymlinks != FALSE,
                                 TmpInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, (void *)TmpInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJQUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aInfo=%p hrc=%Rhrc\n", this, "GuestSession::fsObjQueryInfo", *aInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRemove(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls\n", this, "GuestSession::fsObjRemove", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRemove(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjRemove", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRemoveArray(ComSafeArrayIn(IN_BSTR, aPath),
                                                IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aPath=%zu aProgress=%p\n", this, "GuestSession::fsObjRemoveArray", aPath, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpPath(ComSafeArrayInArg(aPath));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_ENTER(this, (uint32_t)TmpPath.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRemoveArray(TmpPath.array(),
                                   TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpPath.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJREMOVEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjRemoveArray", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjRename(IN_BSTR aOldPath,
                                           IN_BSTR aNewPath,
                                           ComSafeArrayIn(FsObjRenameFlag_T, aFlags))
{
    LogRelFlow(("{%p} %s:enter aOldPath=%ls aNewPath=%ls aFlags=%zu\n", this, "GuestSession::fsObjRename", aOldPath, aNewPath, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpOldPath(aOldPath);
        BSTRInConverter TmpNewPath(aNewPath);
        ArrayInConverter<FsObjRenameFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_ENTER(this, TmpOldPath.str().c_str(), TmpNewPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjRename(TmpOldPath.str(),
                              TmpNewPath.str(),
                              TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 0 /*normal*/, TmpOldPath.str().c_str(), TmpNewPath.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJRENAME_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjRename", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjMove(IN_BSTR aSource,
                                         IN_BSTR aDestination,
                                         ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                                         IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%ls aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjMove", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpSource(aSource);
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FsObjMoveFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_ENTER(this, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjMove(TmpSource.str(),
                            TmpDestination.str(),
                            TmpFlags.array(),
                            TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 0 /*normal*/, TmpSource.str().c_str(), TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjMove", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjMoveArray(ComSafeArrayIn(IN_BSTR, aSource),
                                              IN_BSTR aDestination,
                                              ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%zu aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjMoveArray", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSource(ComSafeArrayInArg(aSource));
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FsObjMoveFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_ENTER(this, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjMoveArray(TmpSource.array(),
                                 TmpDestination.str(),
                                 TmpFlags.array(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJMOVEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjMoveArray", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjCopyArray(ComSafeArrayIn(IN_BSTR, aSource),
                                              IN_BSTR aDestination,
                                              ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                              IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aSource=%zu aDestination=%ls aFlags=%zu aProgress=%p\n", this, "GuestSession::fsObjCopyArray", aSource, aDestination, aFlags, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        ArrayBSTRInConverter TmpSource(ComSafeArrayInArg(aSource));
        BSTRInConverter TmpDestination(aDestination);
        ArrayInConverter<FileCopyFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_ENTER(this, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjCopyArray(TmpSource.array(),
                                 TmpDestination.str(),
                                 TmpFlags.array(),
                                 TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpSource.array().size(), NULL /*for now*/, TmpDestination.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJCOPYARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "GuestSession::fsObjCopyArray", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::FsObjSetACL(IN_BSTR aPath,
                                           BOOL aFollowSymlinks,
                                           IN_BSTR aAcl,
                                           ULONG aMode)
{
    LogRelFlow(("{%p} %s:enter aPath=%ls aFollowSymlinks=%RTbool aAcl=%ls aMode=%RU32\n", this, "GuestSession::fsObjSetACL", aPath, aFollowSymlinks, aAcl, aMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpPath(aPath);
        
        BSTRInConverter TmpAcl(aAcl);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_ENTER(this, TmpPath.str().c_str(), aFollowSymlinks != FALSE, TmpAcl.str().c_str(), aMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = fsObjSetACL(TmpPath.str(),
                              aFollowSymlinks != FALSE,
                              TmpAcl.str(),
                              aMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 0 /*normal*/, TmpPath.str().c_str(), aFollowSymlinks != FALSE, TmpAcl.str().c_str(), aMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aFollowSymlinks != FALSE, 0, aMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_FSOBJSETACL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aFollowSymlinks != FALSE, 0, aMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::fsObjSetACL", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessCreate(IN_BSTR aExecutable,
                                             ComSafeArrayIn(IN_BSTR, aArguments),
                                             ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                                             ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                                             ULONG aTimeoutMS,
                                             IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s:enter aExecutable=%ls aArguments=%zu aEnvironmentChanges=%zu aFlags=%zu aTimeoutMS=%RU32 aGuestProcess=%p\n", this, "GuestSession::processCreate", aExecutable, aArguments, aEnvironmentChanges, aFlags, aTimeoutMS, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        BSTRInConverter TmpExecutable(aExecutable);
        ArrayBSTRInConverter TmpArguments(ComSafeArrayInArg(aArguments));
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));
        ArrayInConverter<ProcessCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_ENTER(this, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = processCreate(TmpExecutable.str(),
                                TmpArguments.array(),
                                TmpEnvironmentChanges.array(),
                                TmpFlags.array(),
                                aTimeoutMS,
                                TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 0 /*normal*/, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processCreate", *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessCreateEx(IN_BSTR aExecutable,
                                               ComSafeArrayIn(IN_BSTR, aArguments),
                                               ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                                               ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                                               ULONG aTimeoutMS,
                                               ProcessPriority_T aPriority,
                                               ComSafeArrayIn(LONG, aAffinity),
                                               IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s:enter aExecutable=%ls aArguments=%zu aEnvironmentChanges=%zu aFlags=%zu aTimeoutMS=%RU32 aPriority=%RU32 aAffinity=%zu aGuestProcess=%p\n", this, "GuestSession::processCreateEx", aExecutable, aArguments, aEnvironmentChanges, aFlags, aTimeoutMS, aPriority, aAffinity, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        BSTRInConverter TmpExecutable(aExecutable);
        ArrayBSTRInConverter TmpArguments(ComSafeArrayInArg(aArguments));
        ArrayBSTRInConverter TmpEnvironmentChanges(ComSafeArrayInArg(aEnvironmentChanges));
        ArrayInConverter<ProcessCreateFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        
        
        ArrayInConverter<LONG> TmpAffinity(ComSafeArrayInArg(aAffinity));
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_ENTER(this, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, aPriority, (uint32_t)TmpAffinity.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = processCreateEx(TmpExecutable.str(),
                                  TmpArguments.array(),
                                  TmpEnvironmentChanges.array(),
                                  TmpFlags.array(),
                                  aTimeoutMS,
                                  aPriority,
                                  TmpAffinity.array(),
                                  TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 0 /*normal*/, TmpExecutable.str().c_str(), (uint32_t)TmpArguments.array().size(), NULL /*for now*/, (uint32_t)TmpEnvironmentChanges.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, aTimeoutMS, aPriority, (uint32_t)TmpAffinity.array().size(), NULL /*for now*/, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, aPriority, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSCREATEEX_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, aTimeoutMS, aPriority, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processCreateEx", *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::ProcessGet(ULONG aPid,
                                          IGuestProcess **aGuestProcess)
{
    LogRelFlow(("{%p} %s:enter aPid=%RU32 aGuestProcess=%p\n", this, "GuestSession::processGet", aPid, aGuestProcess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestProcess);


        
        ComTypeOutConverter<IGuestProcess> TmpGuestProcess(aGuestProcess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_ENTER(this, aPid);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = processGet(aPid,
                             TmpGuestProcess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 0 /*normal*/, aPid, (void *)TmpGuestProcess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 1 /*hrc exception*/, aPid, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_PROCESSGET_RETURN(this, hrc, 9 /*unhandled exception*/, aPid, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aGuestProcess=%p hrc=%Rhrc\n", this, "GuestSession::processGet", *aGuestProcess, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkCreate(IN_BSTR aSymlink,
                                             IN_BSTR aTarget,
                                             SymlinkType_T aType)
{
    LogRelFlow(("{%p} %s:enter aSymlink=%ls aTarget=%ls aType=%RU32\n", this, "GuestSession::symlinkCreate", aSymlink, aTarget, aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpSymlink(aSymlink);
        BSTRInConverter TmpTarget(aTarget);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_ENTER(this, TmpSymlink.str().c_str(), TmpTarget.str().c_str(), aType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkCreate(TmpSymlink.str(),
                                TmpTarget.str(),
                                aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), TmpTarget.str().c_str(), aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKCREATE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestSession::symlinkCreate", hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkExists(IN_BSTR aSymlink,
                                             BOOL *aExists)
{
    LogRelFlow(("{%p} %s:enter aSymlink=%ls aExists=%p\n", this, "GuestSession::symlinkExists", aSymlink, aExists));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExists);


        BSTRInConverter TmpSymlink(aSymlink);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_ENTER(this, TmpSymlink.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkExists(TmpSymlink.str(),
                                aExists);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), *aExists != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, *aExists != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKEXISTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, *aExists != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aExists=%RTbool hrc=%Rhrc\n", this, "GuestSession::symlinkExists", *aExists, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::SymlinkRead(IN_BSTR aSymlink,
                                           ComSafeArrayIn(SymlinkReadFlag_T, aFlags),
                                           BSTR *aTarget)
{
    LogRelFlow(("{%p} %s:enter aSymlink=%ls aFlags=%zu aTarget=%p\n", this, "GuestSession::symlinkRead", aSymlink, aFlags, aTarget));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTarget);


        BSTRInConverter TmpSymlink(aSymlink);
        ArrayInConverter<SymlinkReadFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        BSTROutConverter TmpTarget(aTarget);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_ENTER(this, TmpSymlink.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = symlinkRead(TmpSymlink.str(),
                              TmpFlags.array(),
                              TmpTarget.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 0 /*normal*/, TmpSymlink.str().c_str(), (uint32_t)TmpFlags.array().size(), NULL /*for now*/, TmpTarget.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_SYMLINKREAD_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aTarget=%ls hrc=%Rhrc\n", this, "GuestSession::symlinkRead", *aTarget, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::WaitFor(ULONG aWaitFor,
                                       ULONG aTimeoutMS,
                                       GuestSessionWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s:enter aWaitFor=%RU32 aTimeoutMS=%RU32 aReason=%p\n", this, "GuestSession::waitFor", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_ENTER(this, aWaitFor, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitFor(aWaitFor,
                          aTimeoutMS,
                          aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 0 /*normal*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 1 /*hrc exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFOR_RETURN(this, hrc, 9 /*unhandled exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestSession::waitFor", *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::WaitForArray(ComSafeArrayIn(GuestSessionWaitForFlag_T, aWaitFor),
                                            ULONG aTimeoutMS,
                                            GuestSessionWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s:enter aWaitFor=%zu aTimeoutMS=%RU32 aReason=%p\n", this, "GuestSession::waitForArray", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        ArrayInConverter<GuestSessionWaitForFlag_T> TmpWaitFor(ComSafeArrayInArg(aWaitFor));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_ENTER(this, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForArray(TmpWaitFor.array(),
                               aTimeoutMS,
                               aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSESSION_WAITFORARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestSession::waitForArray", *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod1IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod2IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod3IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod4IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod5IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod6IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod7IGuestSession()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestSessionWrap::InternalAndReservedMethod8IGuestSession()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestSessionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestSessionWrap, IGuestSession)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestSessionWrap.cpp"


// ##### BEGINFILE "GuestProcessWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestProcess.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTPROCESS

#include "GuestProcessWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestProcessWrap)

//
// IProcess properties
//

STDMETHODIMP GuestProcessWrap::COMGETTER(Arguments)(ComSafeArrayOut(BSTR, aArguments))
{
    LogRelFlow(("{%p} %s: enter aArguments=%p\n", this, "GuestProcess::getArguments", aArguments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aArguments);
        ArrayBSTROutConverter TmpArguments(ComSafeArrayOutArg(aArguments));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getArguments(TmpArguments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpArguments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ARGUMENTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aArguments=%zu hrc=%Rhrc\n", this, "GuestProcess::getArguments", ComSafeArraySize(*aArguments), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))
{
    LogRelFlow(("{%p} %s: enter aEnvironment=%p\n", this, "GuestProcess::getEnvironment", aEnvironment));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnvironment);
        ArrayBSTROutConverter TmpEnvironment(ComSafeArrayOutArg(aEnvironment));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnvironment(TmpEnvironment.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpEnvironment.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_ENVIRONMENT_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnvironment=%zu hrc=%Rhrc\n", this, "GuestProcess::getEnvironment", ComSafeArraySize(*aEnvironment), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestProcess::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestProcess::getEventSource", *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(ExecutablePath)(BSTR *aExecutablePath)
{
    LogRelFlow(("{%p} %s: enter aExecutablePath=%p\n", this, "GuestProcess::getExecutablePath", aExecutablePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExecutablePath);
        BSTROutConverter TmpExecutablePath(aExecutablePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExecutablePath(TmpExecutablePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 0 /*normal*/,TmpExecutablePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXECUTABLEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExecutablePath=%ls hrc=%Rhrc\n", this, "GuestProcess::getExecutablePath", *aExecutablePath, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(ExitCode)(LONG *aExitCode)
{
    LogRelFlow(("{%p} %s: enter aExitCode=%p\n", this, "GuestProcess::getExitCode", aExitCode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExitCode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExitCode(aExitCode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 0 /*normal*/,*aExitCode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 1 /*hrc exception*/,*aExitCode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_EXITCODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aExitCode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExitCode=%RI32 hrc=%Rhrc\n", this, "GuestProcess::getExitCode", *aExitCode, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestProcess::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestProcess::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(PID)(ULONG *aPID)
{
    LogRelFlow(("{%p} %s: enter aPID=%p\n", this, "GuestProcess::getPID", aPID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPID(aPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 1 /*hrc exception*/,*aPID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPID=%RU32 hrc=%Rhrc\n", this, "GuestProcess::getPID", *aPID, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(Status)(ProcessStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestProcess::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestProcess::getStatus", *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute1IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute2IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute3IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute4IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute5IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute6IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute7IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::COMGETTER(InternalAndReservedAttribute8IProcess)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestProcess properties
//

STDMETHODIMP GuestProcessWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestProcess::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestProcess::getMidlDoesNotLikeEmptyInterfaces", *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IProcess methods
//

STDMETHODIMP GuestProcessWrap::WaitFor(ULONG aWaitFor,
                                       ULONG aTimeoutMS,
                                       ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s:enter aWaitFor=%RU32 aTimeoutMS=%RU32 aReason=%p\n", this, "GuestProcess::waitFor", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_ENTER(this, aWaitFor, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitFor(aWaitFor,
                          aTimeoutMS,
                          aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 0 /*normal*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 1 /*hrc exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFOR_RETURN(this, hrc, 9 /*unhandled exception*/, aWaitFor, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestProcess::waitFor", *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::WaitForArray(ComSafeArrayIn(ProcessWaitForFlag_T, aWaitFor),
                                            ULONG aTimeoutMS,
                                            ProcessWaitResult_T *aReason)
{
    LogRelFlow(("{%p} %s:enter aWaitFor=%zu aTimeoutMS=%RU32 aReason=%p\n", this, "GuestProcess::waitForArray", aWaitFor, aTimeoutMS, aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReason);


        ArrayInConverter<ProcessWaitForFlag_T> TmpWaitFor(ComSafeArrayInArg(aWaitFor));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_ENTER(this, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForArray(TmpWaitFor.array(),
                               aTimeoutMS,
                               aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpWaitFor.array().size(), NULL /*for now*/, aTimeoutMS, *aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WAITFORARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave aReason=%RU32 hrc=%Rhrc\n", this, "GuestProcess::waitForArray", *aReason, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Read(ULONG aHandle,
                                    ULONG aToRead,
                                    ULONG aTimeoutMS,
                                    ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aHandle=%RU32 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestProcess::read", aHandle, aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_ENTER(this, aHandle, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aHandle,
                       aToRead,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 0 /*normal*/, aHandle, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestProcess::read", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Write(ULONG aHandle,
                                     ULONG aFlags,
                                     ComSafeArrayIn(BYTE, aData),
                                     ULONG aTimeoutMS,
                                     ULONG *aWritten)
{
    LogRelFlow(("{%p} %s:enter aHandle=%RU32 aFlags=%RU32 aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestProcess::write", aHandle, aFlags, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_ENTER(this, aHandle, aFlags, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(aHandle,
                        aFlags,
                        TmpData.array(),
                        aTimeoutMS,
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 0 /*normal*/, aHandle, aFlags, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, aFlags, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, aFlags, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestProcess::write", *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::WriteArray(ULONG aHandle,
                                          ComSafeArrayIn(ProcessInputFlag_T, aFlags),
                                          ComSafeArrayIn(BYTE, aData),
                                          ULONG aTimeoutMS,
                                          ULONG *aWritten)
{
    LogRelFlow(("{%p} %s:enter aHandle=%RU32 aFlags=%zu aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestProcess::writeArray", aHandle, aFlags, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<ProcessInputFlag_T> TmpFlags(ComSafeArrayInArg(aFlags));
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_ENTER(this, aHandle, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = writeArray(aHandle,
                             TmpFlags.array(),
                             TmpData.array(),
                             aTimeoutMS,
                             aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 0 /*normal*/, aHandle, (uint32_t)TmpFlags.array().size(), NULL /*for now*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 1 /*hrc exception*/, aHandle, 0, 0, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_WRITEARRAY_RETURN(this, hrc, 9 /*unhandled exception*/, aHandle, 0, 0, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestProcess::writeArray", *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::Terminate()
{
    LogRelFlow(("{%p} %s:enter\n", this, "GuestProcess::terminate"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = terminate();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTPROCESS_TERMINATE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestProcess::terminate", hrc));
    return hrc;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod1IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod2IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod3IProcess()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestProcessWrap::InternalAndReservedMethod4IProcess()
{
    return E_NOTIMPL;
}

//
// IGuestProcess methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestProcessWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestProcessWrap, IGuestProcess, IProcess)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestProcessWrap.cpp"


// ##### BEGINFILE "GuestDirectoryWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestDirectory.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTDIRECTORY

#include "GuestDirectoryWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestDirectoryWrap)

//
// IDirectory properties
//

STDMETHODIMP GuestDirectoryWrap::COMGETTER(DirectoryName)(BSTR *aDirectoryName)
{
    LogRelFlow(("{%p} %s: enter aDirectoryName=%p\n", this, "GuestDirectory::getDirectoryName", aDirectoryName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDirectoryName);
        BSTROutConverter TmpDirectoryName(aDirectoryName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDirectoryName(TmpDirectoryName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 0 /*normal*/,TmpDirectoryName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_DIRECTORYNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDirectoryName=%ls hrc=%Rhrc\n", this, "GuestDirectory::getDirectoryName", *aDirectoryName, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(Filter)(BSTR *aFilter)
{
    LogRelFlow(("{%p} %s: enter aFilter=%p\n", this, "GuestDirectory::getFilter", aFilter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilter);
        BSTROutConverter TmpFilter(aFilter);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilter(TmpFilter.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 0 /*normal*/,TmpFilter.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_GET_FILTER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilter=%ls hrc=%Rhrc\n", this, "GuestDirectory::getFilter", *aFilter, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute1IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute2IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute3IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute4IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute5IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute6IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute7IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::COMGETTER(InternalAndReservedAttribute8IDirectory)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestDirectory properties
//

STDMETHODIMP GuestDirectoryWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestDirectory::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestDirectory::getMidlDoesNotLikeEmptyInterfaces", *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IDirectory methods
//

STDMETHODIMP GuestDirectoryWrap::Close()
{
    LogRelFlow(("{%p} %s:enter\n", this, "GuestDirectory::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestDirectory::close", hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::Read(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s:enter aObjInfo=%p\n", this, "GuestDirectory::read", aObjInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjInfo);


        ComTypeOutConverter<IFsObjInfo> TmpObjInfo(aObjInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTDIRECTORY_READ_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "GuestDirectory::read", *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod1IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod2IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod3IDirectory()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestDirectoryWrap::InternalAndReservedMethod4IDirectory()
{
    return E_NOTIMPL;
}

//
// IGuestDirectory methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestDirectoryWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestDirectoryWrap, IGuestDirectory, IDirectory)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestDirectoryWrap.cpp"


// ##### BEGINFILE "GuestFileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTFILE

#include "GuestFileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFileWrap)

//
// IFile properties
//

STDMETHODIMP GuestFileWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "GuestFile::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "GuestFile::getEventSource", *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Id)(ULONG *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "GuestFile::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(aId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 0 /*normal*/,*aId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,*aId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,*aId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%RU32 hrc=%Rhrc\n", this, "GuestFile::getId", *aId, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InitialSize)(LONG64 *aInitialSize)
{
    LogRelFlow(("{%p} %s: enter aInitialSize=%p\n", this, "GuestFile::getInitialSize", aInitialSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInitialSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInitialSize(aInitialSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 0 /*normal*/,*aInitialSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aInitialSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_INITIALSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInitialSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInitialSize=%RI64 hrc=%Rhrc\n", this, "GuestFile::getInitialSize", *aInitialSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Offset)(LONG64 *aOffset)
{
    LogRelFlow(("{%p} %s: enter aOffset=%p\n", this, "GuestFile::getOffset", aOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOffset);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOffset(aOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 0 /*normal*/,*aOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 1 /*hrc exception*/,*aOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OFFSET_RETURN(this, hrc, 9 /*unhandled exception*/,*aOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOffset=%RI64 hrc=%Rhrc\n", this, "GuestFile::getOffset", *aOffset, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Status)(FileStatus_T *aStatus)
{
    LogRelFlow(("{%p} %s: enter aStatus=%p\n", this, "GuestFile::getStatus", aStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getStatus(aStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 0 /*normal*/,*aStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_STATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStatus=%RU32 hrc=%Rhrc\n", this, "GuestFile::getStatus", *aStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(Filename)(BSTR *aFilename)
{
    LogRelFlow(("{%p} %s: enter aFilename=%p\n", this, "GuestFile::getFilename", aFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilename);
        BSTROutConverter TmpFilename(aFilename);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilename(TmpFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 0 /*normal*/,TmpFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_FILENAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilename=%ls hrc=%Rhrc\n", this, "GuestFile::getFilename", *aFilename, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(CreationMode)(ULONG *aCreationMode)
{
    LogRelFlow(("{%p} %s: enter aCreationMode=%p\n", this, "GuestFile::getCreationMode", aCreationMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCreationMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCreationMode(aCreationMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 0 /*normal*/,*aCreationMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aCreationMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_CREATIONMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aCreationMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCreationMode=%RU32 hrc=%Rhrc\n", this, "GuestFile::getCreationMode", *aCreationMode, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(OpenAction)(FileOpenAction_T *aOpenAction)
{
    LogRelFlow(("{%p} %s: enter aOpenAction=%p\n", this, "GuestFile::getOpenAction", aOpenAction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOpenAction);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOpenAction(aOpenAction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 0 /*normal*/,*aOpenAction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 1 /*hrc exception*/,*aOpenAction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_OPENACTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aOpenAction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOpenAction=%RU32 hrc=%Rhrc\n", this, "GuestFile::getOpenAction", *aOpenAction, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(AccessMode)(FileAccessMode_T *aAccessMode)
{
    LogRelFlow(("{%p} %s: enter aAccessMode=%p\n", this, "GuestFile::getAccessMode", aAccessMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessMode(aAccessMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 0 /*normal*/,*aAccessMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_GET_ACCESSMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessMode=%RU32 hrc=%Rhrc\n", this, "GuestFile::getAccessMode", *aAccessMode, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute1IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute2IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute3IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute4IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute5IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute6IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute7IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::COMGETTER(InternalAndReservedAttribute8IFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestFile properties
//

STDMETHODIMP GuestFileWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestFile::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestFile::getMidlDoesNotLikeEmptyInterfaces", *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IFile methods
//

STDMETHODIMP GuestFileWrap::Close()
{
    LogRelFlow(("{%p} %s:enter\n", this, "GuestFile::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::close", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::QueryInfo(IFsObjInfo **aObjInfo)
{
    LogRelFlow(("{%p} %s:enter aObjInfo=%p\n", this, "GuestFile::queryInfo", aObjInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjInfo);


        ComTypeOutConverter<IFsObjInfo> TmpObjInfo(aObjInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryInfo(TmpObjInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 0 /*normal*/, (void *)TmpObjInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYINFO_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aObjInfo=%p hrc=%Rhrc\n", this, "GuestFile::queryInfo", *aObjInfo, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::QuerySize(LONG64 *aSize)
{
    LogRelFlow(("{%p} %s:enter aSize=%p\n", this, "GuestFile::querySize", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSize);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = querySize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 0 /*normal*/, *aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 1 /*hrc exception*/, *aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_QUERYSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, *aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSize=%RI64 hrc=%Rhrc\n", this, "GuestFile::querySize", *aSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Read(ULONG aToRead,
                                 ULONG aTimeoutMS,
                                 ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestFile::read", aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_ENTER(this, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aToRead,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 0 /*normal*/, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 1 /*hrc exception*/, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestFile::read", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::ReadAt(LONG64 aOffset,
                                   ULONG aToRead,
                                   ULONG aTimeoutMS,
                                   ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aOffset=%RI64 aToRead=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "GuestFile::readAt", aOffset, aToRead, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_ENTER(this, aOffset, aToRead, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = readAt(aOffset,
                         aToRead,
                         aTimeoutMS,
                         TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 0 /*normal*/, aOffset, aToRead, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aToRead, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_READAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aToRead, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "GuestFile::readAt", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Seek(LONG64 aOffset,
                                 FileSeekOrigin_T aWhence,
                                 LONG64 *aNewOffset)
{
    LogRelFlow(("{%p} %s:enter aOffset=%RI64 aWhence=%RU32 aNewOffset=%p\n", this, "GuestFile::seek", aOffset, aWhence, aNewOffset));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNewOffset);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_ENTER(this, aOffset, aWhence);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = seek(aOffset,
                       aWhence,
                       aNewOffset);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 0 /*normal*/, aOffset, aWhence, *aNewOffset);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aWhence, *aNewOffset);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SEEK_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aWhence, *aNewOffset);
#endif
    }

    LogRelFlow(("{%p} %s: leave aNewOffset=%RI64 hrc=%Rhrc\n", this, "GuestFile::seek", *aNewOffset, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::SetACL(IN_BSTR aAcl,
                                   ULONG aMode)
{
    LogRelFlow(("{%p} %s:enter aAcl=%ls aMode=%RU32\n", this, "GuestFile::setACL", aAcl, aMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpAcl(aAcl);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_ENTER(this, TmpAcl.str().c_str(), aMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setACL(TmpAcl.str(),
                         aMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 0 /*normal*/, TmpAcl.str().c_str(), aMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETACL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::setACL", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::SetSize(LONG64 aSize)
{
    LogRelFlow(("{%p} %s:enter aSize=%RI64\n", this, "GuestFile::setSize", aSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_ENTER(this, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setSize(aSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 0 /*normal*/, aSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 1 /*hrc exception*/, aSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_SETSIZE_RETURN(this, hrc, 9 /*unhandled exception*/, aSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "GuestFile::setSize", hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::Write(ComSafeArrayIn(BYTE, aData),
                                  ULONG aTimeoutMS,
                                  ULONG *aWritten)
{
    LogRelFlow(("{%p} %s:enter aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestFile::write", aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_ENTER(this, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(TmpData.array(),
                        aTimeoutMS,
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestFile::write", *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::WriteAt(LONG64 aOffset,
                                    ComSafeArrayIn(BYTE, aData),
                                    ULONG aTimeoutMS,
                                    ULONG *aWritten)
{
    LogRelFlow(("{%p} %s:enter aOffset=%RI64 aData=%zu aTimeoutMS=%RU32 aWritten=%p\n", this, "GuestFile::writeAt", aOffset, aData, aTimeoutMS, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_ENTER(this, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = writeAt(aOffset,
                          TmpData.array(),
                          aTimeoutMS,
                          aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 0 /*normal*/, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, aTimeoutMS, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, 0, 0, aTimeoutMS, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFILE_WRITEAT_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, 0, 0, aTimeoutMS, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "GuestFile::writeAt", *aWritten, hrc));
    return hrc;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod1IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod2IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod3IFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP GuestFileWrap::InternalAndReservedMethod4IFile()
{
    return E_NOTIMPL;
}

//
// IGuestFile methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestFileWrap, IGuestFile, IFile)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFileWrap.cpp"


// ##### BEGINFILE "GuestFsObjInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestFsObjInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTFSOBJINFO

#include "GuestFsObjInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestFsObjInfoWrap)

//
// IFsObjInfo properties
//

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "GuestFsObjInfo::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(Type)(FsObjType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "GuestFsObjInfo::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(FileAttributes)(BSTR *aFileAttributes)
{
    LogRelFlow(("{%p} %s: enter aFileAttributes=%p\n", this, "GuestFsObjInfo::getFileAttributes", aFileAttributes));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFileAttributes);
        BSTROutConverter TmpFileAttributes(aFileAttributes);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFileAttributes(TmpFileAttributes.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 0 /*normal*/,TmpFileAttributes.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_FILEATTRIBUTES_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFileAttributes=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getFileAttributes", *aFileAttributes, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ObjectSize)(LONG64 *aObjectSize)
{
    LogRelFlow(("{%p} %s: enter aObjectSize=%p\n", this, "GuestFsObjInfo::getObjectSize", aObjectSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObjectSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getObjectSize(aObjectSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 0 /*normal*/,*aObjectSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aObjectSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_OBJECTSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aObjectSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aObjectSize=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getObjectSize", *aObjectSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(AllocatedSize)(LONG64 *aAllocatedSize)
{
    LogRelFlow(("{%p} %s: enter aAllocatedSize=%p\n", this, "GuestFsObjInfo::getAllocatedSize", aAllocatedSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllocatedSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllocatedSize(aAllocatedSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 0 /*normal*/,*aAllocatedSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aAllocatedSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ALLOCATEDSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllocatedSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllocatedSize=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getAllocatedSize", *aAllocatedSize, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(AccessTime)(LONG64 *aAccessTime)
{
    LogRelFlow(("{%p} %s: enter aAccessTime=%p\n", this, "GuestFsObjInfo::getAccessTime", aAccessTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAccessTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAccessTime(aAccessTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 0 /*normal*/,*aAccessTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aAccessTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_ACCESSTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aAccessTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAccessTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getAccessTime", *aAccessTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(BirthTime)(LONG64 *aBirthTime)
{
    LogRelFlow(("{%p} %s: enter aBirthTime=%p\n", this, "GuestFsObjInfo::getBirthTime", aBirthTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBirthTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBirthTime(aBirthTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 0 /*normal*/,*aBirthTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aBirthTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_BIRTHTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aBirthTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBirthTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getBirthTime", *aBirthTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ChangeTime)(LONG64 *aChangeTime)
{
    LogRelFlow(("{%p} %s: enter aChangeTime=%p\n", this, "GuestFsObjInfo::getChangeTime", aChangeTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChangeTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChangeTime(aChangeTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 0 /*normal*/,*aChangeTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 1 /*hrc exception*/,*aChangeTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_CHANGETIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aChangeTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChangeTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getChangeTime", *aChangeTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(ModificationTime)(LONG64 *aModificationTime)
{
    LogRelFlow(("{%p} %s: enter aModificationTime=%p\n", this, "GuestFsObjInfo::getModificationTime", aModificationTime));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aModificationTime);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getModificationTime(aModificationTime);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 0 /*normal*/,*aModificationTime);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 1 /*hrc exception*/,*aModificationTime);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_MODIFICATIONTIME_RETURN(this, hrc, 9 /*unhandled exception*/,*aModificationTime);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aModificationTime=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getModificationTime", *aModificationTime, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UID)(LONG *aUID)
{
    LogRelFlow(("{%p} %s: enter aUID=%p\n", this, "GuestFsObjInfo::getUID", aUID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUID(aUID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 0 /*normal*/,*aUID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 1 /*hrc exception*/,*aUID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_UID_RETURN(this, hrc, 9 /*unhandled exception*/,*aUID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUID=%RI32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getUID", *aUID, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UserName)(BSTR *aUserName)
{
    LogRelFlow(("{%p} %s: enter aUserName=%p\n", this, "GuestFsObjInfo::getUserName", aUserName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserName);
        BSTROutConverter TmpUserName(aUserName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserName(TmpUserName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 0 /*normal*/,TmpUserName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getUserName", *aUserName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GID)(LONG *aGID)
{
    LogRelFlow(("{%p} %s: enter aGID=%p\n", this, "GuestFsObjInfo::getGID", aGID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGID(aGID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 0 /*normal*/,*aGID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 1 /*hrc exception*/,*aGID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGID=%RI32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getGID", *aGID, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GroupName)(BSTR *aGroupName)
{
    LogRelFlow(("{%p} %s: enter aGroupName=%p\n", this, "GuestFsObjInfo::getGroupName", aGroupName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGroupName);
        BSTROutConverter TmpGroupName(aGroupName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGroupName(TmpGroupName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 0 /*normal*/,TmpGroupName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GROUPNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGroupName=%ls hrc=%Rhrc\n", this, "GuestFsObjInfo::getGroupName", *aGroupName, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(NodeId)(LONG64 *aNodeId)
{
    LogRelFlow(("{%p} %s: enter aNodeId=%p\n", this, "GuestFsObjInfo::getNodeId", aNodeId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeId(aNodeId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 0 /*normal*/,*aNodeId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEID_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeId=%RI64 hrc=%Rhrc\n", this, "GuestFsObjInfo::getNodeId", *aNodeId, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(NodeIdDevice)(ULONG *aNodeIdDevice)
{
    LogRelFlow(("{%p} %s: enter aNodeIdDevice=%p\n", this, "GuestFsObjInfo::getNodeIdDevice", aNodeIdDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNodeIdDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNodeIdDevice(aNodeIdDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 0 /*normal*/,*aNodeIdDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aNodeIdDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_NODEIDDEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aNodeIdDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNodeIdDevice=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getNodeIdDevice", *aNodeIdDevice, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(HardLinks)(ULONG *aHardLinks)
{
    LogRelFlow(("{%p} %s: enter aHardLinks=%p\n", this, "GuestFsObjInfo::getHardLinks", aHardLinks));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHardLinks);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHardLinks(aHardLinks);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 0 /*normal*/,*aHardLinks);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 1 /*hrc exception*/,*aHardLinks);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_HARDLINKS_RETURN(this, hrc, 9 /*unhandled exception*/,*aHardLinks);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHardLinks=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getHardLinks", *aHardLinks, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(DeviceNumber)(ULONG *aDeviceNumber)
{
    LogRelFlow(("{%p} %s: enter aDeviceNumber=%p\n", this, "GuestFsObjInfo::getDeviceNumber", aDeviceNumber));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDeviceNumber);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDeviceNumber(aDeviceNumber);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 0 /*normal*/,*aDeviceNumber);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 1 /*hrc exception*/,*aDeviceNumber);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_DEVICENUMBER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDeviceNumber);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDeviceNumber=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getDeviceNumber", *aDeviceNumber, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(GenerationId)(ULONG *aGenerationId)
{
    LogRelFlow(("{%p} %s: enter aGenerationId=%p\n", this, "GuestFsObjInfo::getGenerationId", aGenerationId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGenerationId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGenerationId(aGenerationId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 0 /*normal*/,*aGenerationId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 1 /*hrc exception*/,*aGenerationId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_GENERATIONID_RETURN(this, hrc, 9 /*unhandled exception*/,*aGenerationId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGenerationId=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getGenerationId", *aGenerationId, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(UserFlags)(ULONG *aUserFlags)
{
    LogRelFlow(("{%p} %s: enter aUserFlags=%p\n", this, "GuestFsObjInfo::getUserFlags", aUserFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUserFlags);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUserFlags(aUserFlags);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 0 /*normal*/,*aUserFlags);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 1 /*hrc exception*/,*aUserFlags);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTFSOBJINFO_GET_USERFLAGS_RETURN(this, hrc, 9 /*unhandled exception*/,*aUserFlags);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUserFlags=%RU32 hrc=%Rhrc\n", this, "GuestFsObjInfo::getUserFlags", *aUserFlags, hrc));
    return hrc;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute1IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute2IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute3IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute4IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute5IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute6IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute7IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(InternalAndReservedAttribute8IFsObjInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IGuestFsObjInfo properties
//

STDMETHODIMP GuestFsObjInfoWrap::COMGETTER(MidlDoesNotLikeEmptyInterfaces)(BOOL *aMidlDoesNotLikeEmptyInterfaces)
{
#if 0 /* This is a dummy attribute */
    LogRelFlow(("{%p} %s: enter aMidlDoesNotLikeEmptyInterfaces=%p\n", this, "GuestFsObjInfo::getMidlDoesNotLikeEmptyInterfaces", aMidlDoesNotLikeEmptyInterfaces));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMidlDoesNotLikeEmptyInterfaces);
        
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMidlDoesNotLikeEmptyInterfaces(aMidlDoesNotLikeEmptyInterfaces);
        }
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    }

    LogRelFlow(("{%p} %s: leave *aMidlDoesNotLikeEmptyInterfaces=%RTbool hrc=%Rhrc\n", this, "GuestFsObjInfo::getMidlDoesNotLikeEmptyInterfaces", *aMidlDoesNotLikeEmptyInterfaces, hrc));
    return hrc;
#else  /* dummy attribute */
    NOREF(aMidlDoesNotLikeEmptyInterfaces);
    return E_FAIL;
#endif /* dummy attribute */
}


//
// IFsObjInfo methods
//

//
// IGuestFsObjInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestFsObjInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestFsObjInfoWrap, IGuestFsObjInfo, IFsObjInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestFsObjInfoWrap.cpp"


// ##### BEGINFILE "ProgressWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IProgress.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_PROGRESS

#include "ProgressWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ProgressWrap)

//
// IProgress properties
//

STDMETHODIMP ProgressWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Progress::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Progress::getId", *aId, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Progress::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Progress::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Initiator)(IUnknown **aInitiator)
{
    LogRelFlow(("{%p} %s: enter aInitiator=%p\n", this, "Progress::getInitiator", aInitiator));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInitiator);
        ComTypeOutConverter<IUnknown> TmpInitiator(aInitiator);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInitiator(TmpInitiator.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 0 /*normal*/,(void *)TmpInitiator.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_INITIATOR_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInitiator=%p hrc=%Rhrc\n", this, "Progress::getInitiator", *aInitiator, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Cancelable)(BOOL *aCancelable)
{
    LogRelFlow(("{%p} %s: enter aCancelable=%p\n", this, "Progress::getCancelable", aCancelable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCancelable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCancelable(aCancelable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 0 /*normal*/,*aCancelable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aCancelable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aCancelable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCancelable=%RTbool hrc=%Rhrc\n", this, "Progress::getCancelable", *aCancelable, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Percent)(ULONG *aPercent)
{
    LogRelFlow(("{%p} %s: enter aPercent=%p\n", this, "Progress::getPercent", aPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPercent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPercent(aPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 0 /*normal*/,*aPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 1 /*hrc exception*/,*aPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_PERCENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPercent=%RU32 hrc=%Rhrc\n", this, "Progress::getPercent", *aPercent, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(TimeRemaining)(LONG *aTimeRemaining)
{
    LogRelFlow(("{%p} %s: enter aTimeRemaining=%p\n", this, "Progress::getTimeRemaining", aTimeRemaining));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeRemaining);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeRemaining(aTimeRemaining);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 0 /*normal*/,*aTimeRemaining);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeRemaining);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEREMAINING_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeRemaining);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeRemaining=%RI32 hrc=%Rhrc\n", this, "Progress::getTimeRemaining", *aTimeRemaining, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Completed)(BOOL *aCompleted)
{
    LogRelFlow(("{%p} %s: enter aCompleted=%p\n", this, "Progress::getCompleted", aCompleted));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCompleted);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCompleted(aCompleted);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 0 /*normal*/,*aCompleted != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 1 /*hrc exception*/,*aCompleted != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_COMPLETED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCompleted != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCompleted=%RTbool hrc=%Rhrc\n", this, "Progress::getCompleted", *aCompleted, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Canceled)(BOOL *aCanceled)
{
    LogRelFlow(("{%p} %s: enter aCanceled=%p\n", this, "Progress::getCanceled", aCanceled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCanceled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCanceled(aCanceled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 0 /*normal*/,*aCanceled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 1 /*hrc exception*/,*aCanceled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_CANCELED_RETURN(this, hrc, 9 /*unhandled exception*/,*aCanceled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCanceled=%RTbool hrc=%Rhrc\n", this, "Progress::getCanceled", *aCanceled, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(ResultCode)(LONG *aResultCode)
{
    LogRelFlow(("{%p} %s: enter aResultCode=%p\n", this, "Progress::getResultCode", aResultCode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResultCode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getResultCode(aResultCode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 0 /*normal*/,*aResultCode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 1 /*hrc exception*/,*aResultCode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_RESULTCODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aResultCode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aResultCode=%RI32 hrc=%Rhrc\n", this, "Progress::getResultCode", *aResultCode, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(ErrorInfo)(IVirtualBoxErrorInfo **aErrorInfo)
{
    LogRelFlow(("{%p} %s: enter aErrorInfo=%p\n", this, "Progress::getErrorInfo", aErrorInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aErrorInfo);
        ComTypeOutConverter<IVirtualBoxErrorInfo> TmpErrorInfo(aErrorInfo);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getErrorInfo(TmpErrorInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 0 /*normal*/,(void *)TmpErrorInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_ERRORINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aErrorInfo=%p hrc=%Rhrc\n", this, "Progress::getErrorInfo", *aErrorInfo, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationCount)(ULONG *aOperationCount)
{
    LogRelFlow(("{%p} %s: enter aOperationCount=%p\n", this, "Progress::getOperationCount", aOperationCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationCount(aOperationCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 0 /*normal*/,*aOperationCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationCount=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationCount", *aOperationCount, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Operation)(ULONG *aOperation)
{
    LogRelFlow(("{%p} %s: enter aOperation=%p\n", this, "Progress::getOperation", aOperation));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperation);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperation(aOperation);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 0 /*normal*/,*aOperation);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aOperation);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperation);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperation=%RU32 hrc=%Rhrc\n", this, "Progress::getOperation", *aOperation, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationDescription)(BSTR *aOperationDescription)
{
    LogRelFlow(("{%p} %s: enter aOperationDescription=%p\n", this, "Progress::getOperationDescription", aOperationDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationDescription);
        BSTROutConverter TmpOperationDescription(aOperationDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationDescription(TmpOperationDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpOperationDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONDESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationDescription=%ls hrc=%Rhrc\n", this, "Progress::getOperationDescription", *aOperationDescription, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationPercent)(ULONG *aOperationPercent)
{
    LogRelFlow(("{%p} %s: enter aOperationPercent=%p\n", this, "Progress::getOperationPercent", aOperationPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationPercent);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationPercent(aOperationPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 0 /*normal*/,*aOperationPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONPERCENT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationPercent=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationPercent", *aOperationPercent, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(OperationWeight)(ULONG *aOperationWeight)
{
    LogRelFlow(("{%p} %s: enter aOperationWeight=%p\n", this, "Progress::getOperationWeight", aOperationWeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOperationWeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOperationWeight(aOperationWeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 0 /*normal*/,*aOperationWeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aOperationWeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_OPERATIONWEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aOperationWeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOperationWeight=%RU32 hrc=%Rhrc\n", this, "Progress::getOperationWeight", *aOperationWeight, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(Timeout)(ULONG *aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%p\n", this, "Progress::getTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeout=%RU32 hrc=%Rhrc\n", this, "Progress::getTimeout", *aTimeout, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMSETTER(Timeout)(ULONG aTimeout)
{
    LogRelFlow(("{%p} %s: enter aTimeout=%RU32\n", this, "Progress::setTimeout", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTimeout(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 0 /*normal*/,aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SET_TIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setTimeout", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(EventSource)(IEventSource **aEventSource)
{
    LogRelFlow(("{%p} %s: enter aEventSource=%p\n", this, "Progress::getEventSource", aEventSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEventSource);
        ComTypeOutConverter<IEventSource> TmpEventSource(aEventSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEventSource(TmpEventSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpEventSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_GET_EVENTSOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEventSource=%p hrc=%Rhrc\n", this, "Progress::getEventSource", *aEventSource, hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute1IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute2IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute3IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute4IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute5IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute6IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute7IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute8IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute9IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute10IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute11IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute12IProgress)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IInternalProgressControl properties
//

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute1IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute2IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute3IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute4IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute5IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute6IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute7IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::COMGETTER(InternalAndReservedAttribute8IInternalProgressControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IProgress methods
//

STDMETHODIMP ProgressWrap::WaitForCompletion(LONG aTimeout)
{
    LogRelFlow(("{%p} %s:enter aTimeout=%RI32\n", this, "Progress::waitForCompletion", aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForCompletion(aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 0 /*normal*/, aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFORCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::WaitForOperationCompletion(ULONG aOperation,
                                                      LONG aTimeout)
{
    LogRelFlow(("{%p} %s:enter aOperation=%RU32 aTimeout=%RI32\n", this, "Progress::waitForOperationCompletion", aOperation, aTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_ENTER(this, aOperation, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForOperationCompletion(aOperation,
                                             aTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 0 /*normal*/, aOperation, aTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, aOperation, aTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROPERATIONCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, aOperation, aTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForOperationCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::Cancel()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Progress::cancel"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancel();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_CANCEL_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::cancel", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod1IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod2IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod3IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod4IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod5IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod6IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod7IProgress()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod8IProgress()
{
    return E_NOTIMPL;
}

//
// IInternalProgressControl methods
//

STDMETHODIMP ProgressWrap::SetCurrentOperationProgress(ULONG aPercent)
{
    LogRelFlow(("{%p} %s:enter aPercent=%RU32\n", this, "Progress::setCurrentOperationProgress", aPercent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_ENTER(this, aPercent);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setCurrentOperationProgress(aPercent);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 0 /*normal*/, aPercent);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 1 /*hrc exception*/, aPercent);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETCURRENTOPERATIONPROGRESS_RETURN(this, hrc, 9 /*unhandled exception*/, aPercent);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setCurrentOperationProgress", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::WaitForOtherProgressCompletion(IProgress *aProgressOther,
                                                          ULONG aTimeoutMS)
{
    LogRelFlow(("{%p} %s:enter aProgressOther=%p aTimeoutMS=%RU32\n", this, "Progress::waitForOtherProgressCompletion", aProgressOther, aTimeoutMS));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IProgress> TmpProgressOther(aProgressOther);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_ENTER(this, (void *)TmpProgressOther.ptr(), aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitForOtherProgressCompletion(TmpProgressOther.ptr(),
                                                 aTimeoutMS);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 0 /*normal*/, (void *)TmpProgressOther.ptr(), aTimeoutMS);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 1 /*hrc exception*/, 0, aTimeoutMS);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_WAITFOROTHERPROGRESSCOMPLETION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aTimeoutMS);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::waitForOtherProgressCompletion", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::SetNextOperation(IN_BSTR aNextOperationDescription,
                                            ULONG aNextOperationsWeight)
{
    LogRelFlow(("{%p} %s:enter aNextOperationDescription=%ls aNextOperationsWeight=%RU32\n", this, "Progress::setNextOperation", aNextOperationDescription, aNextOperationsWeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpNextOperationDescription(aNextOperationDescription);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_ENTER(this, TmpNextOperationDescription.str().c_str(), aNextOperationsWeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNextOperation(TmpNextOperationDescription.str(),
                                   aNextOperationsWeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 0 /*normal*/, TmpNextOperationDescription.str().c_str(), aNextOperationsWeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 1 /*hrc exception*/, 0, aNextOperationsWeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_SETNEXTOPERATION_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aNextOperationsWeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::setNextOperation", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::NotifyPointOfNoReturn()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Progress::notifyPointOfNoReturn"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyPointOfNoReturn();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYPOINTOFNORETURN_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::notifyPointOfNoReturn", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::NotifyComplete(LONG aResultCode,
                                          IVirtualBoxErrorInfo *aErrorInfo)
{
    LogRelFlow(("{%p} %s:enter aResultCode=%RI32 aErrorInfo=%p\n", this, "Progress::notifyComplete", aResultCode, aErrorInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpErrorInfo(aErrorInfo);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_ENTER(this, aResultCode, (void *)TmpErrorInfo.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyComplete(aResultCode,
                                 TmpErrorInfo.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 0 /*normal*/, aResultCode, (void *)TmpErrorInfo.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 1 /*hrc exception*/, aResultCode, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PROGRESS_NOTIFYCOMPLETE_RETURN(this, hrc, 9 /*unhandled exception*/, aResultCode, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Progress::notifyComplete", hrc));
    return hrc;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod1IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod2IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod3IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod4IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod5IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod6IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod7IInternalProgressControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP ProgressWrap::InternalAndReservedMethod8IInternalProgressControl()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ProgressWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ProgressWrap, IProgress, IInternalProgressControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ProgressWrap.cpp"


// ##### BEGINFILE "SnapshotWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISnapshot.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_SNAPSHOT

#include "SnapshotWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SnapshotWrap)

//
// ISnapshot properties
//

STDMETHODIMP SnapshotWrap::COMGETTER(Id)(BSTR *aId)
{
    LogRelFlow(("{%p} %s: enter aId=%p\n", this, "Snapshot::getId", aId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aId);
        UuidOutConverter TmpId(aId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getId(TmpId.uuid());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 0 /*normal*/,TmpId.uuid().toStringCurly().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aId=%ls hrc=%Rhrc\n", this, "Snapshot::getId", *aId, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Snapshot::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Snapshot::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Snapshot::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Snapshot::setName", hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "Snapshot::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "Snapshot::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMSETTER(Description)(IN_BSTR aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%ls\n", this, "Snapshot::setDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpDescription(aDescription);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_ENTER(this, TmpDescription.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_SET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Snapshot::setDescription", hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(TimeStamp)(LONG64 *aTimeStamp)
{
    LogRelFlow(("{%p} %s: enter aTimeStamp=%p\n", this, "Snapshot::getTimeStamp", aTimeStamp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTimeStamp);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTimeStamp(aTimeStamp);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 0 /*normal*/,*aTimeStamp);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 1 /*hrc exception*/,*aTimeStamp);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_TIMESTAMP_RETURN(this, hrc, 9 /*unhandled exception*/,*aTimeStamp);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTimeStamp=%RI64 hrc=%Rhrc\n", this, "Snapshot::getTimeStamp", *aTimeStamp, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Online)(BOOL *aOnline)
{
    LogRelFlow(("{%p} %s: enter aOnline=%p\n", this, "Snapshot::getOnline", aOnline));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOnline);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOnline(aOnline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 0 /*normal*/,*aOnline != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 1 /*hrc exception*/,*aOnline != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_ONLINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aOnline != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOnline=%RTbool hrc=%Rhrc\n", this, "Snapshot::getOnline", *aOnline, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Snapshot::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "Snapshot::getMachine", *aMachine, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Parent)(ISnapshot **aParent)
{
    LogRelFlow(("{%p} %s: enter aParent=%p\n", this, "Snapshot::getParent", aParent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aParent);
        ComTypeOutConverter<ISnapshot> TmpParent(aParent);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getParent(TmpParent.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpParent.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_PARENT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aParent=%p hrc=%Rhrc\n", this, "Snapshot::getParent", *aParent, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(Children)(ComSafeArrayOut(ISnapshot *, aChildren))
{
    LogRelFlow(("{%p} %s: enter aChildren=%p\n", this, "Snapshot::getChildren", aChildren));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChildren);
        ArrayComTypeOutConverter<ISnapshot> TmpChildren(ComSafeArrayOutArg(aChildren));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChildren(TmpChildren.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpChildren.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDREN_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChildren=%zu hrc=%Rhrc\n", this, "Snapshot::getChildren", ComSafeArraySize(*aChildren), hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(ChildrenCount)(ULONG *aChildrenCount)
{
    LogRelFlow(("{%p} %s: enter aChildrenCount=%p\n", this, "Snapshot::getChildrenCount", aChildrenCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aChildrenCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getChildrenCount(aChildrenCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 0 /*normal*/,*aChildrenCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aChildrenCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SNAPSHOT_GET_CHILDRENCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aChildrenCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aChildrenCount=%RU32 hrc=%Rhrc\n", this, "Snapshot::getChildrenCount", *aChildrenCount, hrc));
    return hrc;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute1ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute2ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute3ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute4ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute5ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute6ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute7ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::COMGETTER(InternalAndReservedAttribute8ISnapshot)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISnapshot methods
//

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod1ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod2ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod3ISnapshot()
{
    return E_NOTIMPL;
}

STDMETHODIMP SnapshotWrap::InternalAndReservedMethod4ISnapshot()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SnapshotWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotWrap, ISnapshot)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SnapshotWrap.cpp"


// ##### BEGINFILE "MediumAttachmentWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMediumAttachment.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMATTACHMENT

#include "MediumAttachmentWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumAttachmentWrap)

//
// IMediumAttachment properties
//

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "MediumAttachment::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "MediumAttachment::getMachine", *aMachine, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Medium)(IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aMedium=%p\n", this, "MediumAttachment::getMedium", aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMedium(TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_MEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMedium=%p hrc=%Rhrc\n", this, "MediumAttachment::getMedium", *aMedium, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Controller)(BSTR *aController)
{
    LogRelFlow(("{%p} %s: enter aController=%p\n", this, "MediumAttachment::getController", aController));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aController);
        BSTROutConverter TmpController(aController);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getController(TmpController.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 0 /*normal*/,TmpController.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_CONTROLLER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aController=%ls hrc=%Rhrc\n", this, "MediumAttachment::getController", *aController, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Port)(LONG *aPort)
{
    LogRelFlow(("{%p} %s: enter aPort=%p\n", this, "MediumAttachment::getPort", aPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPort);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPort(aPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 0 /*normal*/,*aPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 1 /*hrc exception*/,*aPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PORT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPort=%RI32 hrc=%Rhrc\n", this, "MediumAttachment::getPort", *aPort, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Device)(LONG *aDevice)
{
    LogRelFlow(("{%p} %s: enter aDevice=%p\n", this, "MediumAttachment::getDevice", aDevice));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDevice);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDevice(aDevice);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 0 /*normal*/,*aDevice);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 1 /*hrc exception*/,*aDevice);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DEVICE_RETURN(this, hrc, 9 /*unhandled exception*/,*aDevice);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDevice=%RI32 hrc=%Rhrc\n", this, "MediumAttachment::getDevice", *aDevice, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Type)(DeviceType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "MediumAttachment::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "MediumAttachment::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Passthrough)(BOOL *aPassthrough)
{
    LogRelFlow(("{%p} %s: enter aPassthrough=%p\n", this, "MediumAttachment::getPassthrough", aPassthrough));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPassthrough);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPassthrough(aPassthrough);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 0 /*normal*/,*aPassthrough != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 1 /*hrc exception*/,*aPassthrough != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_PASSTHROUGH_RETURN(this, hrc, 9 /*unhandled exception*/,*aPassthrough != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPassthrough=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getPassthrough", *aPassthrough, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(TemporaryEject)(BOOL *aTemporaryEject)
{
    LogRelFlow(("{%p} %s: enter aTemporaryEject=%p\n", this, "MediumAttachment::getTemporaryEject", aTemporaryEject));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTemporaryEject);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTemporaryEject(aTemporaryEject);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 0 /*normal*/,*aTemporaryEject != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 1 /*hrc exception*/,*aTemporaryEject != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_TEMPORARYEJECT_RETURN(this, hrc, 9 /*unhandled exception*/,*aTemporaryEject != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTemporaryEject=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getTemporaryEject", *aTemporaryEject, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(IsEjected)(BOOL *aIsEjected)
{
    LogRelFlow(("{%p} %s: enter aIsEjected=%p\n", this, "MediumAttachment::getIsEjected", aIsEjected));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIsEjected);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIsEjected(aIsEjected);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 0 /*normal*/,*aIsEjected != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 1 /*hrc exception*/,*aIsEjected != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_ISEJECTED_RETURN(this, hrc, 9 /*unhandled exception*/,*aIsEjected != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIsEjected=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getIsEjected", *aIsEjected, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(NonRotational)(BOOL *aNonRotational)
{
    LogRelFlow(("{%p} %s: enter aNonRotational=%p\n", this, "MediumAttachment::getNonRotational", aNonRotational));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNonRotational);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNonRotational(aNonRotational);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 0 /*normal*/,*aNonRotational != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 1 /*hrc exception*/,*aNonRotational != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_NONROTATIONAL_RETURN(this, hrc, 9 /*unhandled exception*/,*aNonRotational != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNonRotational=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getNonRotational", *aNonRotational, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(Discard)(BOOL *aDiscard)
{
    LogRelFlow(("{%p} %s: enter aDiscard=%p\n", this, "MediumAttachment::getDiscard", aDiscard));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDiscard);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDiscard(aDiscard);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 0 /*normal*/,*aDiscard != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 1 /*hrc exception*/,*aDiscard != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_DISCARD_RETURN(this, hrc, 9 /*unhandled exception*/,*aDiscard != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDiscard=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getDiscard", *aDiscard, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(HotPluggable)(BOOL *aHotPluggable)
{
    LogRelFlow(("{%p} %s: enter aHotPluggable=%p\n", this, "MediumAttachment::getHotPluggable", aHotPluggable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotPluggable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotPluggable(aHotPluggable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 0 /*normal*/,*aHotPluggable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aHotPluggable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_HOTPLUGGABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotPluggable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotPluggable=%RTbool hrc=%Rhrc\n", this, "MediumAttachment::getHotPluggable", *aHotPluggable, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(BandwidthGroup)(IBandwidthGroup **aBandwidthGroup)
{
    LogRelFlow(("{%p} %s: enter aBandwidthGroup=%p\n", this, "MediumAttachment::getBandwidthGroup", aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroup);
        ComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBandwidthGroup(TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/,(void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMATTACHMENT_GET_BANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBandwidthGroup=%p hrc=%Rhrc\n", this, "MediumAttachment::getBandwidthGroup", *aBandwidthGroup, hrc));
    return hrc;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute1IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute2IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute3IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute4IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute5IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute6IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute7IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumAttachmentWrap::COMGETTER(InternalAndReservedAttribute8IMediumAttachment)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMediumAttachment methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumAttachmentWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumAttachmentWrap, IMediumAttachment)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumAttachmentWrap.cpp"


// ##### BEGINFILE "DataStreamWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDataStream.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DATASTREAM

#include "DataStreamWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DataStreamWrap)

//
// IDataStream properties
//

STDMETHODIMP DataStreamWrap::COMGETTER(ReadSize)(ULONG *aReadSize)
{
    LogRelFlow(("{%p} %s: enter aReadSize=%p\n", this, "DataStream::getReadSize", aReadSize));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReadSize);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReadSize(aReadSize);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 0 /*normal*/,*aReadSize);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 1 /*hrc exception*/,*aReadSize);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_GET_READSIZE_RETURN(this, hrc, 9 /*unhandled exception*/,*aReadSize);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReadSize=%RU32 hrc=%Rhrc\n", this, "DataStream::getReadSize", *aReadSize, hrc));
    return hrc;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute1IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute2IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute3IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute4IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute5IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute6IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute7IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::COMGETTER(InternalAndReservedAttribute8IDataStream)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IDataStream methods
//

STDMETHODIMP DataStreamWrap::Read(ULONG aSize,
                                  ULONG aTimeoutMS,
                                  ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aSize=%RU32 aTimeoutMS=%RU32 aData=%p\n", this, "DataStream::read", aSize, aTimeoutMS, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_ENTER(this, aSize, aTimeoutMS);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aSize,
                       aTimeoutMS,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 0 /*normal*/, aSize, aTimeoutMS, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 1 /*hrc exception*/, aSize, aTimeoutMS, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DATASTREAM_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aSize, aTimeoutMS, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "DataStream::read", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod1IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod2IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod3IDataStream()
{
    return E_NOTIMPL;
}

STDMETHODIMP DataStreamWrap::InternalAndReservedMethod4IDataStream()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DataStreamWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DataStreamWrap, IDataStream)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DataStreamWrap.cpp"


// ##### BEGINFILE "MediumIOWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMediumIO.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMIO

#include "MediumIOWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MediumIOWrap)

//
// IMediumIO properties
//

STDMETHODIMP MediumIOWrap::COMGETTER(Medium)(IMedium **aMedium)
{
    LogRelFlow(("{%p} %s: enter aMedium=%p\n", this, "MediumIO::getMedium", aMedium));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMedium);
        ComTypeOutConverter<IMedium> TmpMedium(aMedium);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMedium(TmpMedium.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMedium.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_MEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMedium=%p hrc=%Rhrc\n", this, "MediumIO::getMedium", *aMedium, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(Writable)(BOOL *aWritable)
{
    LogRelFlow(("{%p} %s: enter aWritable=%p\n", this, "MediumIO::getWritable", aWritable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWritable(aWritable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 0 /*normal*/,*aWritable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWritable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_WRITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWritable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWritable=%RTbool hrc=%Rhrc\n", this, "MediumIO::getWritable", *aWritable, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(Explorer)(IVFSExplorer **aExplorer)
{
    LogRelFlow(("{%p} %s: enter aExplorer=%p\n", this, "MediumIO::getExplorer", aExplorer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExplorer);
        ComTypeOutConverter<IVFSExplorer> TmpExplorer(aExplorer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExplorer(TmpExplorer.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 0 /*normal*/,(void *)TmpExplorer.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_GET_EXPLORER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExplorer=%p hrc=%Rhrc\n", this, "MediumIO::getExplorer", *aExplorer, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute1IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute2IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute3IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute4IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute5IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute6IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute7IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::COMGETTER(InternalAndReservedAttribute8IMediumIO)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMediumIO methods
//

STDMETHODIMP MediumIOWrap::Read(LONG64 aOffset,
                                ULONG aSize,
                                ComSafeArrayOut(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aOffset=%RI64 aSize=%RU32 aData=%p\n", this, "MediumIO::read", aOffset, aSize, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aData);


        
        
        ArrayOutConverter<BYTE> TmpData(ComSafeArrayOutArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_ENTER(this, aOffset, aSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = read(aOffset,
                       aSize,
                       TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 0 /*normal*/, aOffset, aSize, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, aSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_READ_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, aSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aData=%zu hrc=%Rhrc\n", this, "MediumIO::read", ComSafeArraySize(*aData), hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::Write(LONG64 aOffset,
                                 ComSafeArrayIn(BYTE, aData),
                                 ULONG *aWritten)
{
    LogRelFlow(("{%p} %s:enter aOffset=%RI64 aData=%zu aWritten=%p\n", this, "MediumIO::write", aOffset, aData, aWritten));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWritten);


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_ENTER(this, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = write(aOffset,
                        TmpData.array(),
                        aWritten);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 0 /*normal*/, aOffset, (uint32_t)TmpData.array().size(), NULL /*for now*/, *aWritten);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 1 /*hrc exception*/, aOffset, 0, 0, *aWritten);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_WRITE_RETURN(this, hrc, 9 /*unhandled exception*/, aOffset, 0, 0, *aWritten);
#endif
    }

    LogRelFlow(("{%p} %s: leave aWritten=%RU32 hrc=%Rhrc\n", this, "MediumIO::write", *aWritten, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::FormatFAT(BOOL aQuick)
{
    LogRelFlow(("{%p} %s:enter aQuick=%RTbool\n", this, "MediumIO::formatFAT", aQuick));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_ENTER(this, aQuick != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = formatFAT(aQuick != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 0 /*normal*/, aQuick != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 1 /*hrc exception*/, aQuick != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_FORMATFAT_RETURN(this, hrc, 9 /*unhandled exception*/, aQuick != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::formatFAT", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::InitializePartitionTable(PartitionTableType_T aFormat,
                                                    BOOL aWholeDiskInOneEntry)
{
    LogRelFlow(("{%p} %s:enter aFormat=%RU32 aWholeDiskInOneEntry=%RTbool\n", this, "MediumIO::initializePartitionTable", aFormat, aWholeDiskInOneEntry));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_ENTER(this, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = initializePartitionTable(aFormat,
                                           aWholeDiskInOneEntry != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 0 /*normal*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 1 /*hrc exception*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_INITIALIZEPARTITIONTABLE_RETURN(this, hrc, 9 /*unhandled exception*/, aFormat, aWholeDiskInOneEntry != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::initializePartitionTable", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::ConvertToStream(IN_BSTR aFormat,
                                           ComSafeArrayIn(MediumVariant_T, aVariant),
                                           ULONG aBufferSize,
                                           IDataStream **aStream,
                                           IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aFormat=%ls aVariant=%zu aBufferSize=%RU32 aStream=%p aProgress=%p\n", this, "MediumIO::convertToStream", aFormat, aVariant, aBufferSize, aStream, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aStream);
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpFormat(aFormat);
        ArrayInConverter<MediumVariant_T> TmpVariant(ComSafeArrayInArg(aVariant));
        
        ComTypeOutConverter<IDataStream> TmpStream(aStream);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_ENTER(this, TmpFormat.str().c_str(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, aBufferSize);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = convertToStream(TmpFormat.str(),
                                  TmpVariant.array(),
                                  aBufferSize,
                                  TmpStream.ptr(),
                                  TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 0 /*normal*/, TmpFormat.str().c_str(), (uint32_t)TmpVariant.array().size(), NULL /*for now*/, aBufferSize, (void *)TmpStream.ptr(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aBufferSize, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CONVERTTOSTREAM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aBufferSize, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aStream=%p aProgress=%p hrc=%Rhrc\n", this, "MediumIO::convertToStream", *aStream, *aProgress, hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::Close()
{
    LogRelFlow(("{%p} %s:enter\n", this, "MediumIO::close"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = close();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MEDIUMIO_CLOSE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MediumIO::close", hrc));
    return hrc;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod1IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod2IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod3IMediumIO()
{
    return E_NOTIMPL;
}

STDMETHODIMP MediumIOWrap::InternalAndReservedMethod4IMediumIO()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MediumIOWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumIOWrap, IMediumIO)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MediumIOWrap.cpp"


// ##### BEGINFILE "MousePointerShapeWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IMousePointerShape.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_MOUSEPOINTERSHAPE

#include "MousePointerShapeWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(MousePointerShapeWrap)

//
// IMousePointerShape properties
//

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "MousePointerShape::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "MousePointerShape::getVisible", *aVisible, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Alpha)(BOOL *aAlpha)
{
    LogRelFlow(("{%p} %s: enter aAlpha=%p\n", this, "MousePointerShape::getAlpha", aAlpha));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAlpha);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAlpha(aAlpha);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 0 /*normal*/,*aAlpha != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 1 /*hrc exception*/,*aAlpha != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_ALPHA_RETURN(this, hrc, 9 /*unhandled exception*/,*aAlpha != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAlpha=%RTbool hrc=%Rhrc\n", this, "MousePointerShape::getAlpha", *aAlpha, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(HotX)(ULONG *aHotX)
{
    LogRelFlow(("{%p} %s: enter aHotX=%p\n", this, "MousePointerShape::getHotX", aHotX));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotX);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotX(aHotX);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 0 /*normal*/,*aHotX);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 1 /*hrc exception*/,*aHotX);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTX_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotX);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotX=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHotX", *aHotX, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(HotY)(ULONG *aHotY)
{
    LogRelFlow(("{%p} %s: enter aHotY=%p\n", this, "MousePointerShape::getHotY", aHotY));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHotY);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHotY(aHotY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 0 /*normal*/,*aHotY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 1 /*hrc exception*/,*aHotY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HOTY_RETURN(this, hrc, 9 /*unhandled exception*/,*aHotY);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHotY=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHotY", *aHotY, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "MousePointerShape::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getWidth", *aWidth, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "MousePointerShape::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "MousePointerShape::getHeight", *aHeight, hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(Shape)(ComSafeArrayOut(BYTE, aShape))
{
    LogRelFlow(("{%p} %s: enter aShape=%p\n", this, "MousePointerShape::getShape", aShape));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShape);
        ArrayOutConverter<BYTE> TmpShape(ComSafeArrayOutArg(aShape));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShape(TmpShape.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpShape.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_MOUSEPOINTERSHAPE_GET_SHAPE_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShape=%zu hrc=%Rhrc\n", this, "MousePointerShape::getShape", ComSafeArraySize(*aShape), hrc));
    return hrc;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute1IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute2IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute3IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP MousePointerShapeWrap::COMGETTER(InternalAndReservedAttribute4IMousePointerShape)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IMousePointerShape methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(MousePointerShapeWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MousePointerShapeWrap, IMousePointerShape)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "MousePointerShapeWrap.cpp"


// ##### BEGINFILE "DisplaySourceBitmapWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IDisplaySourceBitmap.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_DISPLAYSOURCEBITMAP

#include "DisplaySourceBitmapWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(DisplaySourceBitmapWrap)

//
// IDisplaySourceBitmap properties
//

STDMETHODIMP DisplaySourceBitmapWrap::COMGETTER(ScreenId)(ULONG *aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%p\n", this, "DisplaySourceBitmap::getScreenId", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenId(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 0 /*normal*/,*aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 1 /*hrc exception*/,*aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_GET_SCREENID_RETURN(this, hrc, 9 /*unhandled exception*/,*aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreenId=%RU32 hrc=%Rhrc\n", this, "DisplaySourceBitmap::getScreenId", *aScreenId, hrc));
    return hrc;
}


//
// IDisplaySourceBitmap methods
//

STDMETHODIMP DisplaySourceBitmapWrap::QueryBitmapInfo(BYTE **aAddress,
                                                      ULONG *aWidth,
                                                      ULONG *aHeight,
                                                      ULONG *aBitsPerPixel,
                                                      ULONG *aBytesPerLine,
                                                      BitmapFormat_T *aBitmapFormat)
{
    LogRelFlow(("{%p} %s:enter aAddress=%p aWidth=%p aHeight=%p aBitsPerPixel=%p aBytesPerLine=%p aBitmapFormat=%p\n", this, "DisplaySourceBitmap::queryBitmapInfo", aAddress, aWidth, aHeight, aBitsPerPixel, aBytesPerLine, aBitmapFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAddress);
        CheckComArgOutPointerValidThrow(aWidth);
        CheckComArgOutPointerValidThrow(aHeight);
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        CheckComArgOutPointerValidThrow(aBytesPerLine);
        CheckComArgOutPointerValidThrow(aBitmapFormat);


        
        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryBitmapInfo(aAddress,
                                  aWidth,
                                  aHeight,
                                  aBitsPerPixel,
                                  aBytesPerLine,
                                  aBitmapFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 0 /*normal*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 1 /*hrc exception*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_DISPLAYSOURCEBITMAP_QUERYBITMAPINFO_RETURN(this, hrc, 9 /*unhandled exception*/, *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAddress=%p *aWidth=%RU32 *aHeight=%RU32 *aBitsPerPixel=%RU32 *aBytesPerLine=%RU32 *aBitmapFormat=%RU32 hrc=%Rhrc\n", this, "DisplaySourceBitmap::queryBitmapInfo", *aAddress, *aWidth, *aHeight, *aBitsPerPixel, *aBytesPerLine, *aBitmapFormat, hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(DisplaySourceBitmapWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DisplaySourceBitmapWrap, IDisplaySourceBitmap)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "DisplaySourceBitmapWrap.cpp"


// ##### BEGINFILE "FramebufferWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IFramebuffer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_FRAMEBUFFER

#include "FramebufferWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FramebufferWrap)

//
// IFramebuffer properties
//

STDMETHODIMP FramebufferWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "Framebuffer::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getWidth", *aWidth, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "Framebuffer::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getHeight", *aHeight, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(BitsPerPixel)(ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aBitsPerPixel=%p\n", this, "Framebuffer::getBitsPerPixel", aBitsPerPixel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBitsPerPixel(aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 0 /*normal*/,*aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 1 /*hrc exception*/,*aBitsPerPixel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BITSPERPIXEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getBitsPerPixel", *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(BytesPerLine)(ULONG *aBytesPerLine)
{
    LogRelFlow(("{%p} %s: enter aBytesPerLine=%p\n", this, "Framebuffer::getBytesPerLine", aBytesPerLine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBytesPerLine);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBytesPerLine(aBytesPerLine);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 0 /*normal*/,*aBytesPerLine);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 1 /*hrc exception*/,*aBytesPerLine);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_BYTESPERLINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBytesPerLine);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBytesPerLine=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getBytesPerLine", *aBytesPerLine, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(PixelFormat)(BitmapFormat_T *aPixelFormat)
{
    LogRelFlow(("{%p} %s: enter aPixelFormat=%p\n", this, "Framebuffer::getPixelFormat", aPixelFormat));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPixelFormat);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPixelFormat(aPixelFormat);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 0 /*normal*/,*aPixelFormat);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 1 /*hrc exception*/,*aPixelFormat);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_PIXELFORMAT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPixelFormat);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPixelFormat=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getPixelFormat", *aPixelFormat, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(HeightReduction)(ULONG *aHeightReduction)
{
    LogRelFlow(("{%p} %s: enter aHeightReduction=%p\n", this, "Framebuffer::getHeightReduction", aHeightReduction));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeightReduction);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeightReduction(aHeightReduction);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 0 /*normal*/,*aHeightReduction);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 1 /*hrc exception*/,*aHeightReduction);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_HEIGHTREDUCTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeightReduction);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeightReduction=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getHeightReduction", *aHeightReduction, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Overlay)(IFramebufferOverlay **aOverlay)
{
    LogRelFlow(("{%p} %s: enter aOverlay=%p\n", this, "Framebuffer::getOverlay", aOverlay));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOverlay);
        ComTypeOutConverter<IFramebufferOverlay> TmpOverlay(aOverlay);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOverlay(TmpOverlay.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 0 /*normal*/,(void *)TmpOverlay.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_OVERLAY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOverlay=%p hrc=%Rhrc\n", this, "Framebuffer::getOverlay", *aOverlay, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(WinId)(LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s: enter aWinId=%p\n", this, "Framebuffer::getWinId", aWinId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWinId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWinId(aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 0 /*normal*/,*aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 1 /*hrc exception*/,*aWinId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_WINID_RETURN(this, hrc, 9 /*unhandled exception*/,*aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWinId=%RI64 hrc=%Rhrc\n", this, "Framebuffer::getWinId", *aWinId, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::COMGETTER(Capabilities)(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities))
{
    LogRelFlow(("{%p} %s: enter aCapabilities=%p\n", this, "Framebuffer::getCapabilities", aCapabilities));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCapabilities);
        ArrayOutConverter<FramebufferCapabilities_T> TmpCapabilities(ComSafeArrayOutArg(aCapabilities));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCapabilities(TmpCapabilities.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpCapabilities.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GET_CAPABILITIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCapabilities=%zu hrc=%Rhrc\n", this, "Framebuffer::getCapabilities", ComSafeArraySize(*aCapabilities), hrc));
    return hrc;
}


//
// IFramebuffer methods
//

STDMETHODIMP FramebufferWrap::NotifyUpdate(ULONG aX,
                                           ULONG aY,
                                           ULONG aWidth,
                                           ULONG aHeight)
{
    LogRelFlow(("{%p} %s:enter aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Framebuffer::notifyUpdate", aX, aY, aWidth, aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_ENTER(this, aX, aY, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyUpdate(aX,
                               aY,
                               aWidth,
                               aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyUpdate", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::NotifyUpdateImage(ULONG aX,
                                                ULONG aY,
                                                ULONG aWidth,
                                                ULONG aHeight,
                                                ComSafeArrayIn(BYTE, aImage))
{
    LogRelFlow(("{%p} %s:enter aX=%RU32 aY=%RU32 aWidth=%RU32 aHeight=%RU32 aImage=%zu\n", this, "Framebuffer::notifyUpdateImage", aX, aY, aWidth, aHeight, aImage));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        ArrayInConverter<BYTE> TmpImage(ComSafeArrayInArg(aImage));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_ENTER(this, aX, aY, aWidth, aHeight, (uint32_t)TmpImage.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyUpdateImage(aX,
                                    aY,
                                    aWidth,
                                    aHeight,
                                    TmpImage.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 0 /*normal*/, aX, aY, aWidth, aHeight, (uint32_t)TmpImage.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 1 /*hrc exception*/, aX, aY, aWidth, aHeight, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYUPDATEIMAGE_RETURN(this, hrc, 9 /*unhandled exception*/, aX, aY, aWidth, aHeight, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyUpdateImage", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::NotifyChange(ULONG aScreenId,
                                           ULONG aXOrigin,
                                           ULONG aYOrigin,
                                           ULONG aWidth,
                                           ULONG aHeight)
{
    LogRelFlow(("{%p} %s:enter aScreenId=%RU32 aXOrigin=%RU32 aYOrigin=%RU32 aWidth=%RU32 aHeight=%RU32\n", this, "Framebuffer::notifyChange", aScreenId, aXOrigin, aYOrigin, aWidth, aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_ENTER(this, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notifyChange(aScreenId,
                               aXOrigin,
                               aYOrigin,
                               aWidth,
                               aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 0 /*normal*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aScreenId, aXOrigin, aYOrigin, aWidth, aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notifyChange", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::VideoModeSupported(ULONG aWidth,
                                                 ULONG aHeight,
                                                 ULONG aBpp,
                                                 BOOL *aSupported)
{
    LogRelFlow(("{%p} %s:enter aWidth=%RU32 aHeight=%RU32 aBpp=%RU32 aSupported=%p\n", this, "Framebuffer::videoModeSupported", aWidth, aHeight, aBpp, aSupported));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSupported);


        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_ENTER(this, aWidth, aHeight, aBpp);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = videoModeSupported(aWidth,
                                     aHeight,
                                     aBpp,
                                     aSupported);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 0 /*normal*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 1 /*hrc exception*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_VIDEOMODESUPPORTED_RETURN(this, hrc, 9 /*unhandled exception*/, aWidth, aHeight, aBpp, *aSupported != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aSupported=%RTbool hrc=%Rhrc\n", this, "Framebuffer::videoModeSupported", *aSupported, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::GetVisibleRegion(BYTE *aRectangles,
                                               ULONG aCount,
                                               ULONG *aCountCopied)
{
    LogRelFlow(("{%p} %s:enter aRectangles=%p aCount=%RU32 aCountCopied=%p\n", this, "Framebuffer::getVisibleRegion", aRectangles, aCount, aCountCopied));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCountCopied);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_ENTER(this, aRectangles, aCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisibleRegion(aRectangles,
                                   aCount,
                                   aCountCopied);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount, *aCountCopied);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 1 /*hrc exception*/, aRectangles, aCount, *aCountCopied);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_GETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount, *aCountCopied);
#endif
    }

    LogRelFlow(("{%p} %s: leave aCountCopied=%RU32 hrc=%Rhrc\n", this, "Framebuffer::getVisibleRegion", *aCountCopied, hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::SetVisibleRegion(BYTE *aRectangles,
                                               ULONG aCount)
{
    LogRelFlow(("{%p} %s:enter aRectangles=%p aCount=%RU32\n", this, "Framebuffer::setVisibleRegion", aRectangles, aCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_ENTER(this, aRectangles, aCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVisibleRegion(aRectangles,
                                   aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 0 /*normal*/, aRectangles, aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 1 /*hrc exception*/, aRectangles, aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_SETVISIBLEREGION_RETURN(this, hrc, 9 /*unhandled exception*/, aRectangles, aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::setVisibleRegion", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::ProcessVHWACommand(BYTE *aCommand,
                                                 LONG aEnmCmd,
                                                 BOOL aFromGuest)
{
    LogRelFlow(("{%p} %s:enter aCommand=%p aEnmCmd=%RI32 aFromGuest=%RTbool\n", this, "Framebuffer::processVHWACommand", aCommand, aEnmCmd, aFromGuest));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_ENTER(this, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = processVHWACommand(aCommand,
                                     aEnmCmd,
                                     aFromGuest != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 0 /*normal*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 1 /*hrc exception*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_PROCESSVHWACOMMAND_RETURN(this, hrc, 9 /*unhandled exception*/, aCommand, aEnmCmd, aFromGuest != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::processVHWACommand", hrc));
    return hrc;
}

STDMETHODIMP FramebufferWrap::Notify3DEvent(ULONG aType,
                                            ComSafeArrayIn(BYTE, aData))
{
    LogRelFlow(("{%p} %s:enter aType=%RU32 aData=%zu\n", this, "Framebuffer::notify3DEvent", aType, aData));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        ArrayInConverter<BYTE> TmpData(ComSafeArrayInArg(aData));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_ENTER(this, aType, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = notify3DEvent(aType,
                                TmpData.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 0 /*normal*/, aType, (uint32_t)TmpData.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 1 /*hrc exception*/, aType, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FRAMEBUFFER_NOTIFY3DEVENT_RETURN(this, hrc, 9 /*unhandled exception*/, aType, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Framebuffer::notify3DEvent", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FramebufferWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FramebufferWrap, IFramebuffer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FramebufferWrap.cpp"


// ##### BEGINFILE "GuestScreenInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IGuestScreenInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_GUESTSCREENINFO

#include "GuestScreenInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(GuestScreenInfoWrap)

//
// IGuestScreenInfo properties
//

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(ScreenId)(ULONG *aScreenId)
{
    LogRelFlow(("{%p} %s: enter aScreenId=%p\n", this, "GuestScreenInfo::getScreenId", aScreenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aScreenId);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getScreenId(aScreenId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 0 /*normal*/,*aScreenId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 1 /*hrc exception*/,*aScreenId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_SCREENID_RETURN(this, hrc, 9 /*unhandled exception*/,*aScreenId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aScreenId=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getScreenId", *aScreenId, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(GuestMonitorStatus)(GuestMonitorStatus_T *aGuestMonitorStatus)
{
    LogRelFlow(("{%p} %s: enter aGuestMonitorStatus=%p\n", this, "GuestScreenInfo::getGuestMonitorStatus", aGuestMonitorStatus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGuestMonitorStatus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGuestMonitorStatus(aGuestMonitorStatus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 0 /*normal*/,*aGuestMonitorStatus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 1 /*hrc exception*/,*aGuestMonitorStatus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_GUESTMONITORSTATUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aGuestMonitorStatus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGuestMonitorStatus=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getGuestMonitorStatus", *aGuestMonitorStatus, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Primary)(BOOL *aPrimary)
{
    LogRelFlow(("{%p} %s: enter aPrimary=%p\n", this, "GuestScreenInfo::getPrimary", aPrimary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPrimary);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPrimary(aPrimary);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 0 /*normal*/,*aPrimary != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 1 /*hrc exception*/,*aPrimary != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_PRIMARY_RETURN(this, hrc, 9 /*unhandled exception*/,*aPrimary != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPrimary=%RTbool hrc=%Rhrc\n", this, "GuestScreenInfo::getPrimary", *aPrimary, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Origin)(BOOL *aOrigin)
{
    LogRelFlow(("{%p} %s: enter aOrigin=%p\n", this, "GuestScreenInfo::getOrigin", aOrigin));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOrigin);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOrigin(aOrigin);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 0 /*normal*/,*aOrigin != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 1 /*hrc exception*/,*aOrigin != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aOrigin != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOrigin=%RTbool hrc=%Rhrc\n", this, "GuestScreenInfo::getOrigin", *aOrigin, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(OriginX)(LONG *aOriginX)
{
    LogRelFlow(("{%p} %s: enter aOriginX=%p\n", this, "GuestScreenInfo::getOriginX", aOriginX));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOriginX);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOriginX(aOriginX);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 0 /*normal*/,*aOriginX);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 1 /*hrc exception*/,*aOriginX);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINX_RETURN(this, hrc, 9 /*unhandled exception*/,*aOriginX);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOriginX=%RI32 hrc=%Rhrc\n", this, "GuestScreenInfo::getOriginX", *aOriginX, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(OriginY)(LONG *aOriginY)
{
    LogRelFlow(("{%p} %s: enter aOriginY=%p\n", this, "GuestScreenInfo::getOriginY", aOriginY));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aOriginY);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getOriginY(aOriginY);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 0 /*normal*/,*aOriginY);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 1 /*hrc exception*/,*aOriginY);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_ORIGINY_RETURN(this, hrc, 9 /*unhandled exception*/,*aOriginY);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aOriginY=%RI32 hrc=%Rhrc\n", this, "GuestScreenInfo::getOriginY", *aOriginY, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Width)(ULONG *aWidth)
{
    LogRelFlow(("{%p} %s: enter aWidth=%p\n", this, "GuestScreenInfo::getWidth", aWidth));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWidth);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWidth(aWidth);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 0 /*normal*/,*aWidth);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 1 /*hrc exception*/,*aWidth);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_WIDTH_RETURN(this, hrc, 9 /*unhandled exception*/,*aWidth);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWidth=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getWidth", *aWidth, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(Height)(ULONG *aHeight)
{
    LogRelFlow(("{%p} %s: enter aHeight=%p\n", this, "GuestScreenInfo::getHeight", aHeight));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHeight);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHeight(aHeight);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 0 /*normal*/,*aHeight);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 1 /*hrc exception*/,*aHeight);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_HEIGHT_RETURN(this, hrc, 9 /*unhandled exception*/,*aHeight);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHeight=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getHeight", *aHeight, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(BitsPerPixel)(ULONG *aBitsPerPixel)
{
    LogRelFlow(("{%p} %s: enter aBitsPerPixel=%p\n", this, "GuestScreenInfo::getBitsPerPixel", aBitsPerPixel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBitsPerPixel);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBitsPerPixel(aBitsPerPixel);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 0 /*normal*/,*aBitsPerPixel);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 1 /*hrc exception*/,*aBitsPerPixel);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_BITSPERPIXEL_RETURN(this, hrc, 9 /*unhandled exception*/,*aBitsPerPixel);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBitsPerPixel=%RU32 hrc=%Rhrc\n", this, "GuestScreenInfo::getBitsPerPixel", *aBitsPerPixel, hrc));
    return hrc;
}

STDMETHODIMP GuestScreenInfoWrap::COMGETTER(ExtendedInfo)(BSTR *aExtendedInfo)
{
    LogRelFlow(("{%p} %s: enter aExtendedInfo=%p\n", this, "GuestScreenInfo::getExtendedInfo", aExtendedInfo));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aExtendedInfo);
        BSTROutConverter TmpExtendedInfo(aExtendedInfo);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getExtendedInfo(TmpExtendedInfo.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 0 /*normal*/,TmpExtendedInfo.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_GUESTSCREENINFO_GET_EXTENDEDINFO_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aExtendedInfo=%ls hrc=%Rhrc\n", this, "GuestScreenInfo::getExtendedInfo", *aExtendedInfo, hrc));
    return hrc;
}


//
// IGuestScreenInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(GuestScreenInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestScreenInfoWrap, IGuestScreenInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "GuestScreenInfoWrap.cpp"


// ##### BEGINFILE "SerialPortWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISerialPort.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_SERIALPORT

#include "SerialPortWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SerialPortWrap)

//
// ISerialPort properties
//

STDMETHODIMP SerialPortWrap::COMGETTER(Slot)(ULONG *aSlot)
{
    LogRelFlow(("{%p} %s: enter aSlot=%p\n", this, "SerialPort::getSlot", aSlot));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSlot);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSlot(aSlot);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 0 /*normal*/,*aSlot);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 1 /*hrc exception*/,*aSlot);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SLOT_RETURN(this, hrc, 9 /*unhandled exception*/,*aSlot);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSlot=%RU32 hrc=%Rhrc\n", this, "SerialPort::getSlot", *aSlot, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "SerialPort::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "SerialPort::getEnabled", *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "SerialPort::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(IOBase)(ULONG *aIOBase)
{
    LogRelFlow(("{%p} %s: enter aIOBase=%p\n", this, "SerialPort::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_SERIALPORT_GET_IOBASE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIOBase(aIOBase);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IOBASE_RETURN(this, hrc, 0 /*normal*/,*aIOBase);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_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_SERIALPORT_GET_IOBASE_RETURN(this, hrc, 9 /*unhandled exception*/,*aIOBase);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIOBase=%RU32 hrc=%Rhrc\n", this, "SerialPort::getIOBase", *aIOBase, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(IOBase)(ULONG aIOBase)
{
    LogRelFlow(("{%p} %s: enter aIOBase=%RU32\n", this, "SerialPort::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_SERIALPORT_SET_IOBASE_ENTER(this, aIOBase);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIOBase(aIOBase);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IOBASE_RETURN(this, hrc, 0 /*normal*/,aIOBase);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_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_SERIALPORT_SET_IOBASE_RETURN(this, hrc, 9 /*unhandled exception*/,aIOBase);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setIOBase", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(IRQ)(ULONG *aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%p\n", this, "SerialPort::getIRQ", aIRQ));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aIRQ);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getIRQ(aIRQ);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 0 /*normal*/,*aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 1 /*hrc exception*/,*aIRQ);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,*aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aIRQ=%RU32 hrc=%Rhrc\n", this, "SerialPort::getIRQ", *aIRQ, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(IRQ)(ULONG aIRQ)
{
    LogRelFlow(("{%p} %s: enter aIRQ=%RU32\n", this, "SerialPort::setIRQ", aIRQ));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_ENTER(this, aIRQ);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setIRQ(aIRQ);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 0 /*normal*/,aIRQ);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 1 /*hrc exception*/,aIRQ);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_IRQ_RETURN(this, hrc, 9 /*unhandled exception*/,aIRQ);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setIRQ", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(HostMode)(PortMode_T *aHostMode)
{
    LogRelFlow(("{%p} %s: enter aHostMode=%p\n", this, "SerialPort::getHostMode", aHostMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostMode(aHostMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 0 /*normal*/,*aHostMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aHostMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_HOSTMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aHostMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostMode=%RU32 hrc=%Rhrc\n", this, "SerialPort::getHostMode", *aHostMode, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(HostMode)(PortMode_T aHostMode)
{
    LogRelFlow(("{%p} %s: enter aHostMode=%RU32\n", this, "SerialPort::setHostMode", aHostMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_ENTER(this, aHostMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostMode(aHostMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 0 /*normal*/,aHostMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 1 /*hrc exception*/,aHostMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_HOSTMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aHostMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setHostMode", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Server)(BOOL *aServer)
{
    LogRelFlow(("{%p} %s: enter aServer=%p\n", this, "SerialPort::getServer", aServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aServer);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getServer(aServer);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 0 /*normal*/,*aServer != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 1 /*hrc exception*/,*aServer != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_SERVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aServer != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aServer=%RTbool hrc=%Rhrc\n", this, "SerialPort::getServer", *aServer, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Server)(BOOL aServer)
{
    LogRelFlow(("{%p} %s: enter aServer=%RTbool\n", this, "SerialPort::setServer", aServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_ENTER(this, aServer != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setServer(aServer != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 0 /*normal*/,aServer != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 1 /*hrc exception*/,aServer != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_SERVER_RETURN(this, hrc, 9 /*unhandled exception*/,aServer != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setServer", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(Path)(BSTR *aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%p\n", this, "SerialPort::getPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPath);
        BSTROutConverter TmpPath(aPath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPath=%ls hrc=%Rhrc\n", this, "SerialPort::getPath", *aPath, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(Path)(IN_BSTR aPath)
{
    LogRelFlow(("{%p} %s: enter aPath=%ls\n", this, "SerialPort::setPath", aPath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpPath(aPath);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_ENTER(this, TmpPath.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPath(TmpPath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 0 /*normal*/,TmpPath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_PATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setPath", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(UartType)(UartType_T *aUartType)
{
    LogRelFlow(("{%p} %s: enter aUartType=%p\n", this, "SerialPort::getUartType", aUartType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUartType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUartType(aUartType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 0 /*normal*/,*aUartType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aUartType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_GET_UARTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUartType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUartType=%RU32 hrc=%Rhrc\n", this, "SerialPort::getUartType", *aUartType, hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMSETTER(UartType)(UartType_T aUartType)
{
    LogRelFlow(("{%p} %s: enter aUartType=%RU32\n", this, "SerialPort::setUartType", aUartType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_ENTER(this, aUartType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUartType(aUartType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 0 /*normal*/,aUartType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aUartType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SERIALPORT_SET_UARTTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aUartType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "SerialPort::setUartType", hrc));
    return hrc;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute1ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute2ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute3ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SerialPortWrap::COMGETTER(InternalAndReservedAttribute4ISerialPort)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ISerialPort methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SerialPortWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SerialPortWrap, ISerialPort)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SerialPortWrap.cpp"


// ##### BEGINFILE "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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", 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.rc();
        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", *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.rc();
        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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", 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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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.rc();
        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", 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.rc();
        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.rc();
        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", *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 "VRDEServerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVRDEServer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_VRDESERVER

#include "VRDEServerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VRDEServerWrap)

//
// IVRDEServer properties
//

STDMETHODIMP VRDEServerWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "VRDEServer::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getEnabled", *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(Enabled)(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%RTbool\n", this, "VRDEServer::setEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setEnabled(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 0 /*normal*/,aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setEnabled", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthType)(AuthType_T *aAuthType)
{
    LogRelFlow(("{%p} %s: enter aAuthType=%p\n", this, "VRDEServer::getAuthType", aAuthType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthType(aAuthType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 0 /*normal*/,*aAuthType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aAuthType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAuthType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthType=%RU32 hrc=%Rhrc\n", this, "VRDEServer::getAuthType", *aAuthType, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthType)(AuthType_T aAuthType)
{
    LogRelFlow(("{%p} %s: enter aAuthType=%RU32\n", this, "VRDEServer::setAuthType", aAuthType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_ENTER(this, aAuthType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthType(aAuthType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 0 /*normal*/,aAuthType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aAuthType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aAuthType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthType", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthTimeout)(ULONG *aAuthTimeout)
{
    LogRelFlow(("{%p} %s: enter aAuthTimeout=%p\n", this, "VRDEServer::getAuthTimeout", aAuthTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthTimeout);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthTimeout(aAuthTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 0 /*normal*/,*aAuthTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,*aAuthTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHTIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,*aAuthTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthTimeout=%RU32 hrc=%Rhrc\n", this, "VRDEServer::getAuthTimeout", *aAuthTimeout, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthTimeout)(ULONG aAuthTimeout)
{
    LogRelFlow(("{%p} %s: enter aAuthTimeout=%RU32\n", this, "VRDEServer::setAuthTimeout", aAuthTimeout));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_ENTER(this, aAuthTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthTimeout(aAuthTimeout);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 0 /*normal*/,aAuthTimeout);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 1 /*hrc exception*/,aAuthTimeout);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHTIMEOUT_RETURN(this, hrc, 9 /*unhandled exception*/,aAuthTimeout);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthTimeout", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AllowMultiConnection)(BOOL *aAllowMultiConnection)
{
    LogRelFlow(("{%p} %s: enter aAllowMultiConnection=%p\n", this, "VRDEServer::getAllowMultiConnection", aAllowMultiConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAllowMultiConnection);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllowMultiConnection(aAllowMultiConnection);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 0 /*normal*/,*aAllowMultiConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,*aAllowMultiConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_ALLOWMULTICONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aAllowMultiConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAllowMultiConnection=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getAllowMultiConnection", *aAllowMultiConnection, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AllowMultiConnection)(BOOL aAllowMultiConnection)
{
    LogRelFlow(("{%p} %s: enter aAllowMultiConnection=%RTbool\n", this, "VRDEServer::setAllowMultiConnection", aAllowMultiConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_ENTER(this, aAllowMultiConnection != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAllowMultiConnection(aAllowMultiConnection != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 0 /*normal*/,aAllowMultiConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,aAllowMultiConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_ALLOWMULTICONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,aAllowMultiConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAllowMultiConnection", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(ReuseSingleConnection)(BOOL *aReuseSingleConnection)
{
    LogRelFlow(("{%p} %s: enter aReuseSingleConnection=%p\n", this, "VRDEServer::getReuseSingleConnection", aReuseSingleConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aReuseSingleConnection);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getReuseSingleConnection(aReuseSingleConnection);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 0 /*normal*/,*aReuseSingleConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,*aReuseSingleConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_REUSESINGLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,*aReuseSingleConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aReuseSingleConnection=%RTbool hrc=%Rhrc\n", this, "VRDEServer::getReuseSingleConnection", *aReuseSingleConnection, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(ReuseSingleConnection)(BOOL aReuseSingleConnection)
{
    LogRelFlow(("{%p} %s: enter aReuseSingleConnection=%RTbool\n", this, "VRDEServer::setReuseSingleConnection", aReuseSingleConnection));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_ENTER(this, aReuseSingleConnection != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setReuseSingleConnection(aReuseSingleConnection != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 0 /*normal*/,aReuseSingleConnection != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 1 /*hrc exception*/,aReuseSingleConnection != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_REUSESINGLECONNECTION_RETURN(this, hrc, 9 /*unhandled exception*/,aReuseSingleConnection != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setReuseSingleConnection", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(VRDEExtPack)(BSTR *aVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aVRDEExtPack=%p\n", this, "VRDEServer::getVRDEExtPack", aVRDEExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEExtPack);
        BSTROutConverter TmpVRDEExtPack(aVRDEExtPack);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEExtPack(TmpVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEExtPack=%ls hrc=%Rhrc\n", this, "VRDEServer::getVRDEExtPack", *aVRDEExtPack, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(VRDEExtPack)(IN_BSTR aVRDEExtPack)
{
    LogRelFlow(("{%p} %s: enter aVRDEExtPack=%ls\n", this, "VRDEServer::setVRDEExtPack", aVRDEExtPack));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpVRDEExtPack(aVRDEExtPack);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_ENTER(this, TmpVRDEExtPack.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRDEExtPack(TmpVRDEExtPack.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 0 /*normal*/,TmpVRDEExtPack.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_VRDEEXTPACK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setVRDEExtPack", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(AuthLibrary)(BSTR *aAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aAuthLibrary=%p\n", this, "VRDEServer::getAuthLibrary", aAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAuthLibrary);
        BSTROutConverter TmpAuthLibrary(aAuthLibrary);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAuthLibrary(TmpAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_AUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAuthLibrary=%ls hrc=%Rhrc\n", this, "VRDEServer::getAuthLibrary", *aAuthLibrary, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMSETTER(AuthLibrary)(IN_BSTR aAuthLibrary)
{
    LogRelFlow(("{%p} %s: enter aAuthLibrary=%ls\n", this, "VRDEServer::setAuthLibrary", aAuthLibrary));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpAuthLibrary(aAuthLibrary);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_ENTER(this, TmpAuthLibrary.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAuthLibrary(TmpAuthLibrary.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 0 /*normal*/,TmpAuthLibrary.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SET_AUTHLIBRARY_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setAuthLibrary", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(VRDEProperties)(ComSafeArrayOut(BSTR, aVRDEProperties))
{
    LogRelFlow(("{%p} %s: enter aVRDEProperties=%p\n", this, "VRDEServer::getVRDEProperties", aVRDEProperties));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEProperties);
        ArrayBSTROutConverter TmpVRDEProperties(ComSafeArrayOutArg(aVRDEProperties));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEProperties(TmpVRDEProperties.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpVRDEProperties.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GET_VRDEPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEProperties=%zu hrc=%Rhrc\n", this, "VRDEServer::getVRDEProperties", ComSafeArraySize(*aVRDEProperties), hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute1IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute2IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute3IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::COMGETTER(InternalAndReservedAttribute4IVRDEServer)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IVRDEServer methods
//

STDMETHODIMP VRDEServerWrap::SetVRDEProperty(IN_BSTR aKey,
                                             IN_BSTR aValue)
{
    LogRelFlow(("{%p} %s:enter aKey=%ls aValue=%ls\n", this, "VRDEServer::setVRDEProperty", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpKey(aKey);
        BSTRInConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_ENTER(this, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setVRDEProperty(TmpKey.str(),
                                  TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_SETVRDEPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VRDEServer::setVRDEProperty", hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::GetVRDEProperty(IN_BSTR aKey,
                                             BSTR *aValue)
{
    LogRelFlow(("{%p} %s:enter aKey=%ls aValue=%p\n", this, "VRDEServer::getVRDEProperty", aKey, aValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValue);


        BSTRInConverter TmpKey(aKey);
        BSTROutConverter TmpValue(aValue);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_ENTER(this, TmpKey.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEProperty(TmpKey.str(),
                                  TmpValue.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpKey.str().c_str(), TmpValue.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VRDESERVER_GETVRDEPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aValue=%ls hrc=%Rhrc\n", this, "VRDEServer::getVRDEProperty", *aValue, hrc));
    return hrc;
}

STDMETHODIMP VRDEServerWrap::InternalAndReservedMethod1IVRDEServer()
{
    return E_NOTIMPL;
}

STDMETHODIMP VRDEServerWrap::InternalAndReservedMethod2IVRDEServer()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VRDEServerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VRDEServerWrap, IVRDEServer)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VRDEServerWrap.cpp"


// ##### BEGINFILE "SessionWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ISession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_SESSION

#include "SessionWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(SessionWrap)

//
// ISession properties
//

STDMETHODIMP SessionWrap::COMGETTER(State)(SessionState_T *aState)
{
    LogRelFlow(("{%p} %s: enter aState=%p\n", this, "Session::getState", aState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getState(aState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 0 /*normal*/,*aState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 1 /*hrc exception*/,*aState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_STATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aState=%RU32 hrc=%Rhrc\n", this, "Session::getState", *aState, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Type)(SessionType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "Session::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "Session::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "Session::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "Session::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "Session::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::setName", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Machine)(IMachine **aMachine)
{
    LogRelFlow(("{%p} %s: enter aMachine=%p\n", this, "Session::getMachine", aMachine));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMachine);
        ComTypeOutConverter<IMachine> TmpMachine(aMachine);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMachine(TmpMachine.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpMachine.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_MACHINE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMachine=%p hrc=%Rhrc\n", this, "Session::getMachine", *aMachine, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(Console)(IConsole **aConsole)
{
    LogRelFlow(("{%p} %s: enter aConsole=%p\n", this, "Session::getConsole", aConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aConsole);
        ComTypeOutConverter<IConsole> TmpConsole(aConsole);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getConsole(TmpConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_CONSOLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aConsole=%p hrc=%Rhrc\n", this, "Session::getConsole", *aConsole, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute1ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute2ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute3ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute4ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute5ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute6ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute7ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::COMGETTER(InternalAndReservedAttribute8ISession)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IInternalSessionControl properties
//

STDMETHODIMP SessionWrap::COMGETTER(PID)(ULONG *aPID)
{
    LogRelFlow(("{%p} %s: enter aPID=%p\n", this, "Session::getPID", aPID));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPID);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPID(aPID);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 0 /*normal*/,*aPID);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 1 /*hrc exception*/,*aPID);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_PID_RETURN(this, hrc, 9 /*unhandled exception*/,*aPID);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPID=%RU32 hrc=%Rhrc\n", this, "Session::getPID", *aPID, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(RemoteConsole)(IConsole **aRemoteConsole)
{
    LogRelFlow(("{%p} %s: enter aRemoteConsole=%p\n", this, "Session::getRemoteConsole", aRemoteConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRemoteConsole);
        ComTypeOutConverter<IConsole> TmpRemoteConsole(aRemoteConsole);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRemoteConsole(TmpRemoteConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpRemoteConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_REMOTECONSOLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRemoteConsole=%p hrc=%Rhrc\n", this, "Session::getRemoteConsole", *aRemoteConsole, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::COMGETTER(NominalState)(MachineState_T *aNominalState)
{
    LogRelFlow(("{%p} %s: enter aNominalState=%p\n", this, "Session::getNominalState", aNominalState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNominalState);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNominalState(aNominalState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 0 /*normal*/,*aNominalState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 1 /*hrc exception*/,*aNominalState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_GET_NOMINALSTATE_RETURN(this, hrc, 9 /*unhandled exception*/,*aNominalState);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNominalState=%RU32 hrc=%Rhrc\n", this, "Session::getNominalState", *aNominalState, hrc));
    return hrc;
}


//
// ISession methods
//

STDMETHODIMP SessionWrap::UnlockMachine()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Session::unlockMachine"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = unlockMachine();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNLOCKMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::unlockMachine", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod1ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod2ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod3ISession()
{
    return E_NOTIMPL;
}

STDMETHODIMP SessionWrap::InternalAndReservedMethod4ISession()
{
    return E_NOTIMPL;
}

//
// IInternalSessionControl methods
//

#ifndef VBOX_WITH_XPCOM
STDMETHODIMP SessionWrap::AssignMachine(IMachine *aMachine,
                                        LockType_T aLockType,
                                        IN_BSTR aTokenId)
{
    LogRelFlow(("{%p} %s:enter aMachine=%p aLockType=%RU32 aTokenId=%ls\n", this, "Session::assignMachine", aMachine, aLockType, aTokenId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        
        BSTRInConverter TmpTokenId(aTokenId);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_ENTER(this, (void *)TmpMachine.ptr(), aLockType, TmpTokenId.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignMachine(TmpMachine.ptr(),
                                aLockType,
                                TmpTokenId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), aLockType, TmpTokenId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLockType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_MIDL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLockType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignMachine", hrc));
    return hrc;
}
#endif /* !VBOX_WITH_XPCOM */

#ifdef VBOX_WITH_XPCOM
STDMETHODIMP SessionWrap::AssignMachine(IMachine *aMachine,
                                        LockType_T aLockType,
                                        IToken *aToken)
{
    LogRelFlow(("{%p} %s:enter aMachine=%p aLockType=%RU32 aToken=%p\n", this, "Session::assignMachine", aMachine, aLockType, aToken));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        
        ComTypeInConverter<IToken> TmpToken(aToken);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_ENTER(this, (void *)TmpMachine.ptr(), aLockType, (void *)TmpToken.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignMachine(TmpMachine.ptr(),
                                aLockType,
                                TmpToken.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), aLockType, (void *)TmpToken.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 1 /*hrc exception*/, 0, aLockType, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNMACHINE_XPIDL_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aLockType, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignMachine", hrc));
    return hrc;
}
#endif /* VBOX_WITH_XPCOM */

STDMETHODIMP SessionWrap::AssignRemoteMachine(IMachine *aMachine,
                                              IConsole *aConsole)
{
    LogRelFlow(("{%p} %s:enter aMachine=%p aConsole=%p\n", this, "Session::assignRemoteMachine", aMachine, aConsole));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMachine> TmpMachine(aMachine);
        ComTypeInConverter<IConsole> TmpConsole(aConsole);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_ENTER(this, (void *)TmpMachine.ptr(), (void *)TmpConsole.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = assignRemoteMachine(TmpMachine.ptr(),
                                      TmpConsole.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMachine.ptr(), (void *)TmpConsole.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ASSIGNREMOTEMACHINE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::assignRemoteMachine", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::UpdateMachineState(MachineState_T aMachineState)
{
    LogRelFlow(("{%p} %s:enter aMachineState=%RU32\n", this, "Session::updateMachineState", aMachineState));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_ENTER(this, aMachineState);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = updateMachineState(aMachineState);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 0 /*normal*/, aMachineState);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 1 /*hrc exception*/, aMachineState);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UPDATEMACHINESTATE_RETURN(this, hrc, 9 /*unhandled exception*/, aMachineState);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::updateMachineState", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::Uninitialize()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Session::uninitialize"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = uninitialize();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_UNINITIALIZE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::uninitialize", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnNetworkAdapterChange(INetworkAdapter *aNetworkAdapter,
                                                 BOOL aChangeAdapter)
{
    LogRelFlow(("{%p} %s:enter aNetworkAdapter=%p aChangeAdapter=%RTbool\n", this, "Session::onNetworkAdapterChange", aNetworkAdapter, aChangeAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<INetworkAdapter> TmpNetworkAdapter(aNetworkAdapter);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_ENTER(this, (void *)TmpNetworkAdapter.ptr(), aChangeAdapter != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onNetworkAdapterChange(TmpNetworkAdapter.ptr(),
                                         aChangeAdapter != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpNetworkAdapter.ptr(), aChangeAdapter != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aChangeAdapter != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONNETWORKADAPTERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aChangeAdapter != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onNetworkAdapterChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnAudioAdapterChange(IAudioAdapter *aAudioAdapter)
{
    LogRelFlow(("{%p} %s:enter aAudioAdapter=%p\n", this, "Session::onAudioAdapterChange", aAudioAdapter));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IAudioAdapter> TmpAudioAdapter(aAudioAdapter);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_ENTER(this, (void *)TmpAudioAdapter.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onAudioAdapterChange(TmpAudioAdapter.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpAudioAdapter.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONAUDIOADAPTERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onAudioAdapterChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnSerialPortChange(ISerialPort *aSerialPort)
{
    LogRelFlow(("{%p} %s:enter aSerialPort=%p\n", this, "Session::onSerialPortChange", aSerialPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<ISerialPort> TmpSerialPort(aSerialPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_ENTER(this, (void *)TmpSerialPort.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onSerialPortChange(TmpSerialPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpSerialPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSERIALPORTCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onSerialPortChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnParallelPortChange(IParallelPort *aParallelPort)
{
    LogRelFlow(("{%p} %s:enter aParallelPort=%p\n", this, "Session::onParallelPortChange", aParallelPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IParallelPort> TmpParallelPort(aParallelPort);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_ENTER(this, (void *)TmpParallelPort.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onParallelPortChange(TmpParallelPort.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpParallelPort.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONPARALLELPORTCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onParallelPortChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnStorageControllerChange(IN_BSTR aMachineId,
                                                    IN_BSTR aControllerName)
{
    LogRelFlow(("{%p} %s:enter aMachineId=%ls aControllerName=%ls\n", this, "Session::onStorageControllerChange", aMachineId, aControllerName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpMachineId(aMachineId);
        BSTRInConverter TmpControllerName(aControllerName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_ENTER(this, TmpMachineId.uuid().toStringCurly().c_str(), TmpControllerName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onStorageControllerChange(TmpMachineId.uuid(),
                                            TmpControllerName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 0 /*normal*/, TmpMachineId.uuid().toStringCurly().c_str(), TmpControllerName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGECONTROLLERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onStorageControllerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnMediumChange(IMediumAttachment *aMediumAttachment,
                                         BOOL aForce)
{
    LogRelFlow(("{%p} %s:enter aMediumAttachment=%p aForce=%RTbool\n", this, "Session::onMediumChange", aMediumAttachment, aForce));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_ENTER(this, (void *)TmpMediumAttachment.ptr(), aForce != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onMediumChange(TmpMediumAttachment.ptr(),
                                 aForce != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aForce != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aForce != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONMEDIUMCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aForce != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onMediumChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnStorageDeviceChange(IMediumAttachment *aMediumAttachment,
                                                BOOL aRemove,
                                                BOOL aSilent)
{
    LogRelFlow(("{%p} %s:enter aMediumAttachment=%p aRemove=%RTbool aSilent=%RTbool\n", this, "Session::onStorageDeviceChange", aMediumAttachment, aRemove, aSilent));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_ENTER(this, (void *)TmpMediumAttachment.ptr(), aRemove != FALSE, aSilent != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onStorageDeviceChange(TmpMediumAttachment.ptr(),
                                        aRemove != FALSE,
                                        aSilent != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aRemove != FALSE, aSilent != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0, aRemove != FALSE, aSilent != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSTORAGEDEVICECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aRemove != FALSE, aSilent != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onStorageDeviceChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnVMProcessPriorityChange(VMProcPriority_T aPriority)
{
    LogRelFlow(("{%p} %s:enter aPriority=%RU32\n", this, "Session::onVMProcessPriorityChange", aPriority));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_ENTER(this, aPriority);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onVMProcessPriorityChange(aPriority);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 0 /*normal*/, aPriority);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aPriority);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVMPROCESSPRIORITYCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aPriority);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onVMProcessPriorityChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnClipboardModeChange(ClipboardMode_T aClipboardMode)
{
    LogRelFlow(("{%p} %s:enter aClipboardMode=%RU32\n", this, "Session::onClipboardModeChange", aClipboardMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_ENTER(this, aClipboardMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onClipboardModeChange(aClipboardMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aClipboardMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aClipboardMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aClipboardMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onClipboardModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnClipboardFileTransferModeChange(BOOL aEnabled)
{
    LogRelFlow(("{%p} %s:enter aEnabled=%RTbool\n", this, "Session::onClipboardFileTransferModeChange", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_ENTER(this, aEnabled != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onClipboardFileTransferModeChange(aEnabled != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCLIPBOARDFILETRANSFERMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onClipboardFileTransferModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnDnDModeChange(DnDMode_T aDndMode)
{
    LogRelFlow(("{%p} %s:enter aDndMode=%RU32\n", this, "Session::onDnDModeChange", aDndMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_ENTER(this, aDndMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onDnDModeChange(aDndMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 0 /*normal*/, aDndMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aDndMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONDNDMODECHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aDndMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onDnDModeChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnCPUChange(ULONG aCpu,
                                      BOOL aAdd)
{
    LogRelFlow(("{%p} %s:enter aCpu=%RU32 aAdd=%RTbool\n", this, "Session::onCPUChange", aCpu, aAdd));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_ENTER(this, aCpu, aAdd != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onCPUChange(aCpu,
                              aAdd != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 0 /*normal*/, aCpu, aAdd != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aCpu, aAdd != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aCpu, aAdd != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onCPUChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnCPUExecutionCapChange(ULONG aExecutionCap)
{
    LogRelFlow(("{%p} %s:enter aExecutionCap=%RU32\n", this, "Session::onCPUExecutionCapChange", aExecutionCap));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_ENTER(this, aExecutionCap);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onCPUExecutionCapChange(aExecutionCap);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 0 /*normal*/, aExecutionCap);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aExecutionCap);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONCPUEXECUTIONCAPCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aExecutionCap);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onCPUExecutionCapChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnVRDEServerChange(BOOL aRestart)
{
    LogRelFlow(("{%p} %s:enter aRestart=%RTbool\n", this, "Session::onVRDEServerChange", aRestart));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_ENTER(this, aRestart != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onVRDEServerChange(aRestart != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 0 /*normal*/, aRestart != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aRestart != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONVRDESERVERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aRestart != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onVRDEServerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnRecordingChange(BOOL aEnable)
{
    LogRelFlow(("{%p} %s:enter aEnable=%RTbool\n", this, "Session::onRecordingChange", aEnable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGCHANGE_ENTER(this, aEnable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onRecordingChange(aEnable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGCHANGE_RETURN(this, hrc, 0 /*normal*/, aEnable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aEnable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONRECORDINGCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aEnable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onRecordingChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBControllerChange()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Session::onUSBControllerChange"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBControllerChange();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBCONTROLLERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBControllerChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnSharedFolderChange(BOOL aGlobal)
{
    LogRelFlow(("{%p} %s:enter aGlobal=%RTbool\n", this, "Session::onSharedFolderChange", aGlobal));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_ENTER(this, aGlobal != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onSharedFolderChange(aGlobal != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 0 /*normal*/, aGlobal != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, aGlobal != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHAREDFOLDERCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, aGlobal != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onSharedFolderChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBDeviceAttach(IUSBDevice *aDevice,
                                            IVirtualBoxErrorInfo *aError,
                                            ULONG aMaskedInterfaces,
                                            IN_BSTR aCaptureFilename)
{
    LogRelFlow(("{%p} %s:enter aDevice=%p aError=%p aMaskedInterfaces=%RU32 aCaptureFilename=%ls\n", this, "Session::onUSBDeviceAttach", aDevice, aError, aMaskedInterfaces, aCaptureFilename));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IUSBDevice> TmpDevice(aDevice);
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpError(aError);
        
        BSTRInConverter TmpCaptureFilename(aCaptureFilename);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_ENTER(this, (void *)TmpDevice.ptr(), (void *)TmpError.ptr(), aMaskedInterfaces, TmpCaptureFilename.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBDeviceAttach(TmpDevice.ptr(),
                                    TmpError.ptr(),
                                    aMaskedInterfaces,
                                    TmpCaptureFilename.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 0 /*normal*/, (void *)TmpDevice.ptr(), (void *)TmpError.ptr(), aMaskedInterfaces, TmpCaptureFilename.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, aMaskedInterfaces, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEATTACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, aMaskedInterfaces, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBDeviceAttach", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnUSBDeviceDetach(IN_BSTR aId,
                                            IVirtualBoxErrorInfo *aError)
{
    LogRelFlow(("{%p} %s:enter aId=%ls aError=%p\n", this, "Session::onUSBDeviceDetach", aId, aError));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        UuidInConverter TmpId(aId);
        ComTypeInConverter<IVirtualBoxErrorInfo> TmpError(aError);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_ENTER(this, TmpId.uuid().toStringCurly().c_str(), (void *)TmpError.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onUSBDeviceDetach(TmpId.uuid(),
                                    TmpError.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 0 /*normal*/, TmpId.uuid().toStringCurly().c_str(), (void *)TmpError.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONUSBDEVICEDETACH_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onUSBDeviceDetach", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnShowWindow(BOOL aCheck,
                                       BOOL *aCanShow,
                                       LONG64 *aWinId)
{
    LogRelFlow(("{%p} %s:enter aCheck=%RTbool aCanShow=%p aWinId=%p\n", this, "Session::onShowWindow", aCheck, aCanShow, aWinId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCanShow);
        CheckComArgOutPointerValidThrow(aWinId);


        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_ENTER(this, aCheck != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onShowWindow(aCheck != FALSE,
                               aCanShow,
                               aWinId);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 0 /*normal*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 1 /*hrc exception*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONSHOWWINDOW_RETURN(this, hrc, 9 /*unhandled exception*/, aCheck != FALSE, *aCanShow != FALSE, *aWinId);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCanShow=%RTbool *aWinId=%RI64 hrc=%Rhrc\n", this, "Session::onShowWindow", *aCanShow, *aWinId, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
{
    LogRelFlow(("{%p} %s:enter aBandwidthGroup=%p\n", this, "Session::onBandwidthGroupChange", aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_ENTER(this, (void *)TmpBandwidthGroup.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onBandwidthGroupChange(TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 0 /*normal*/, (void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONBANDWIDTHGROUPCHANGE_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onBandwidthGroupChange", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::AccessGuestProperty(IN_BSTR aName,
                                              IN_BSTR aValue,
                                              IN_BSTR aFlags,
                                              ULONG aAccessMode,
                                              BSTR *aRetValue,
                                              LONG64 *aRetTimestamp,
                                              BSTR *aRetFlags)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aValue=%ls aFlags=%ls aAccessMode=%RU32 aRetValue=%p aRetTimestamp=%p aRetFlags=%p\n", this, "Session::accessGuestProperty", aName, aValue, aFlags, aAccessMode, aRetValue, aRetTimestamp, aRetFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRetValue);
        CheckComArgOutPointerValidThrow(aRetTimestamp);
        CheckComArgOutPointerValidThrow(aRetFlags);


        BSTRInConverter TmpName(aName);
        BSTRInConverter TmpValue(aValue);
        BSTRInConverter TmpFlags(aFlags);
        
        BSTROutConverter TmpRetValue(aRetValue);
        
        BSTROutConverter TmpRetFlags(aRetFlags);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_ENTER(this, TmpName.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str(), aAccessMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = accessGuestProperty(TmpName.str(),
                                      TmpValue.str(),
                                      TmpFlags.str(),
                                      aAccessMode,
                                      TmpRetValue.str(),
                                      aRetTimestamp,
                                      TmpRetFlags.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), TmpValue.str().c_str(), TmpFlags.str().c_str(), aAccessMode, TmpRetValue.str().c_str(), *aRetTimestamp, TmpRetFlags.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, aAccessMode, 0, *aRetTimestamp, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ACCESSGUESTPROPERTY_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, aAccessMode, 0, *aRetTimestamp, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRetValue=%ls *aRetTimestamp=%RI64 *aRetFlags=%ls hrc=%Rhrc\n", this, "Session::accessGuestProperty", *aRetValue, *aRetTimestamp, *aRetFlags, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::EnumerateGuestProperties(IN_BSTR aPatterns,
                                                   ComSafeArrayOut(BSTR, aKeys),
                                                   ComSafeArrayOut(BSTR, aValues),
                                                   ComSafeArrayOut(LONG64, aTimestamps),
                                                   ComSafeArrayOut(BSTR, aFlags))
{
    LogRelFlow(("{%p} %s:enter aPatterns=%ls aKeys=%p aValues=%p aTimestamps=%p aFlags=%p\n", this, "Session::enumerateGuestProperties", aPatterns, aKeys, aValues, aTimestamps, aFlags));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aKeys);
        CheckComArgOutPointerValidThrow(aValues);
        CheckComArgOutPointerValidThrow(aTimestamps);
        CheckComArgOutPointerValidThrow(aFlags);


        BSTRInConverter TmpPatterns(aPatterns);
        ArrayBSTROutConverter TmpKeys(ComSafeArrayOutArg(aKeys));
        ArrayBSTROutConverter TmpValues(ComSafeArrayOutArg(aValues));
        ArrayOutConverter<LONG64> TmpTimestamps(ComSafeArrayOutArg(aTimestamps));
        ArrayBSTROutConverter TmpFlags(ComSafeArrayOutArg(aFlags));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_ENTER(this, TmpPatterns.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = enumerateGuestProperties(TmpPatterns.str(),
                                           TmpKeys.array(),
                                           TmpValues.array(),
                                           TmpTimestamps.array(),
                                           TmpFlags.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 0 /*normal*/, TmpPatterns.str().c_str(), (uint32_t)TmpKeys.array().size(), NULL /*for now*/, (uint32_t)TmpValues.array().size(), NULL /*for now*/, (uint32_t)TmpTimestamps.array().size(), NULL /*for now*/, (uint32_t)TmpFlags.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENUMERATEGUESTPROPERTIES_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0, 0, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aKeys=%zu *aValues=%zu *aTimestamps=%zu *aFlags=%zu hrc=%Rhrc\n", this, "Session::enumerateGuestProperties", ComSafeArraySize(*aKeys), ComSafeArraySize(*aValues), ComSafeArraySize(*aTimestamps), ComSafeArraySize(*aFlags), hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::OnlineMergeMedium(IMediumAttachment *aMediumAttachment,
                                            ULONG aSourceIdx,
                                            ULONG aTargetIdx,
                                            IProgress *aProgress)
{
    LogRelFlow(("{%p} %s:enter aMediumAttachment=%p aSourceIdx=%RU32 aTargetIdx=%RU32 aProgress=%p\n", this, "Session::onlineMergeMedium", aMediumAttachment, aSourceIdx, aTargetIdx, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ComTypeInConverter<IMediumAttachment> TmpMediumAttachment(aMediumAttachment);
        
        
        ComTypeInConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_ENTER(this, (void *)TmpMediumAttachment.ptr(), aSourceIdx, aTargetIdx, (void *)TmpProgress.ptr());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = onlineMergeMedium(TmpMediumAttachment.ptr(),
                                    aSourceIdx,
                                    aTargetIdx,
                                    TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 0 /*normal*/, (void *)TmpMediumAttachment.ptr(), aSourceIdx, aTargetIdx, (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 1 /*hrc exception*/, 0, aSourceIdx, aTargetIdx, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ONLINEMERGEMEDIUM_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aSourceIdx, aTargetIdx, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::onlineMergeMedium", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::ReconfigureMediumAttachments(ComSafeArrayIn(IMediumAttachment *, aAttachments))
{
    LogRelFlow(("{%p} %s:enter aAttachments=%zu\n", this, "Session::reconfigureMediumAttachments", aAttachments));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        ArrayComTypeInConverter<IMediumAttachment> TmpAttachments(ComSafeArrayInArg(aAttachments));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_ENTER(this, (uint32_t)TmpAttachments.array().size(), NULL /*for now*/);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = reconfigureMediumAttachments(TmpAttachments.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpAttachments.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RECONFIGUREMEDIUMATTACHMENTS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::reconfigureMediumAttachments", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::EnableVMMStatistics(BOOL aEnable)
{
    LogRelFlow(("{%p} %s:enter aEnable=%RTbool\n", this, "Session::enableVMMStatistics", aEnable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_ENTER(this, aEnable != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = enableVMMStatistics(aEnable != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 0 /*normal*/, aEnable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 1 /*hrc exception*/, aEnable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_ENABLEVMMSTATISTICS_RETURN(this, hrc, 9 /*unhandled exception*/, aEnable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::enableVMMStatistics", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::PauseWithReason(Reason_T aReason)
{
    LogRelFlow(("{%p} %s:enter aReason=%RU32\n", this, "Session::pauseWithReason", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_ENTER(this, aReason);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = pauseWithReason(aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_PAUSEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::pauseWithReason", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::ResumeWithReason(Reason_T aReason)
{
    LogRelFlow(("{%p} %s:enter aReason=%RU32\n", this, "Session::resumeWithReason", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_ENTER(this, aReason);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = resumeWithReason(aReason);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_RESUMEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::resumeWithReason", hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::SaveStateWithReason(Reason_T aReason,
                                              IProgress *aProgress,
                                              ISnapshot *aSnapshot,
                                              IN_BSTR aStateFilePath,
                                              BOOL aPauseVM,
                                              BOOL *aLeftPaused)
{
    LogRelFlow(("{%p} %s:enter aReason=%RU32 aProgress=%p aSnapshot=%p aStateFilePath=%ls aPauseVM=%RTbool aLeftPaused=%p\n", this, "Session::saveStateWithReason", aReason, aProgress, aSnapshot, aStateFilePath, aPauseVM, aLeftPaused));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLeftPaused);


        
        ComTypeInConverter<IProgress> TmpProgress(aProgress);
        ComTypeInConverter<ISnapshot> TmpSnapshot(aSnapshot);
        BSTRInConverter TmpStateFilePath(aStateFilePath);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_ENTER(this, aReason, (void *)TmpProgress.ptr(), (void *)TmpSnapshot.ptr(), TmpStateFilePath.str().c_str(), aPauseVM != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = saveStateWithReason(aReason,
                                      TmpProgress.ptr(),
                                      TmpSnapshot.ptr(),
                                      TmpStateFilePath.str(),
                                      aPauseVM != FALSE,
                                      aLeftPaused);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 0 /*normal*/, aReason, (void *)TmpProgress.ptr(), (void *)TmpSnapshot.ptr(), TmpStateFilePath.str().c_str(), aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/, aReason, 0, 0, 0, aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_SAVESTATEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/, aReason, 0, 0, 0, aPauseVM != FALSE, *aLeftPaused != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLeftPaused=%RTbool hrc=%Rhrc\n", this, "Session::saveStateWithReason", *aLeftPaused, hrc));
    return hrc;
}

STDMETHODIMP SessionWrap::CancelSaveStateWithReason()
{
    LogRelFlow(("{%p} %s:enter\n", this, "Session::cancelSaveStateWithReason"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = cancelSaveStateWithReason();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_SESSION_CANCELSAVESTATEWITHREASON_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "Session::cancelSaveStateWithReason", hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(SessionWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionWrap, ISession, IInternalSessionControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "SessionWrap.cpp"


// ##### BEGINFILE "StorageControllerWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IStorageController.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_STORAGECONTROLLER

#include "StorageControllerWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(StorageControllerWrap)

//
// IStorageController properties
//

STDMETHODIMP StorageControllerWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "StorageController::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "StorageController::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(Name)(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s: enter aName=%ls\n", this, "StorageController::setName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setName", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MaxDevicesPerPortCount)(ULONG *aMaxDevicesPerPortCount)
{
    LogRelFlow(("{%p} %s: enter aMaxDevicesPerPortCount=%p\n", this, "StorageController::getMaxDevicesPerPortCount", aMaxDevicesPerPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxDevicesPerPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxDevicesPerPortCount(aMaxDevicesPerPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMaxDevicesPerPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxDevicesPerPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXDEVICESPERPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxDevicesPerPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxDevicesPerPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMaxDevicesPerPortCount", *aMaxDevicesPerPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MinPortCount)(ULONG *aMinPortCount)
{
    LogRelFlow(("{%p} %s: enter aMinPortCount=%p\n", this, "StorageController::getMinPortCount", aMinPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinPortCount(aMinPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMinPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMinPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MINPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMinPortCount", *aMinPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(MaxPortCount)(ULONG *aMaxPortCount)
{
    LogRelFlow(("{%p} %s: enter aMaxPortCount=%p\n", this, "StorageController::getMaxPortCount", aMaxPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaxPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaxPortCount(aMaxPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aMaxPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aMaxPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_MAXPORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaxPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaxPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getMaxPortCount", *aMaxPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Instance)(ULONG *aInstance)
{
    LogRelFlow(("{%p} %s: enter aInstance=%p\n", this, "StorageController::getInstance", aInstance));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInstance);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstance(aInstance);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 0 /*normal*/,*aInstance);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 1 /*hrc exception*/,*aInstance);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_INSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/,*aInstance);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInstance=%RU32 hrc=%Rhrc\n", this, "StorageController::getInstance", *aInstance, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(Instance)(ULONG aInstance)
{
    LogRelFlow(("{%p} %s: enter aInstance=%RU32\n", this, "StorageController::setInstance", aInstance));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_ENTER(this, aInstance);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setInstance(aInstance);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 0 /*normal*/,aInstance);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 1 /*hrc exception*/,aInstance);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_INSTANCE_RETURN(this, hrc, 9 /*unhandled exception*/,aInstance);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setInstance", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(PortCount)(ULONG *aPortCount)
{
    LogRelFlow(("{%p} %s: enter aPortCount=%p\n", this, "StorageController::getPortCount", aPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPortCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPortCount(aPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 0 /*normal*/,*aPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_PORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPortCount=%RU32 hrc=%Rhrc\n", this, "StorageController::getPortCount", *aPortCount, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(PortCount)(ULONG aPortCount)
{
    LogRelFlow(("{%p} %s: enter aPortCount=%RU32\n", this, "StorageController::setPortCount", aPortCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_ENTER(this, aPortCount);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setPortCount(aPortCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 0 /*normal*/,aPortCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 1 /*hrc exception*/,aPortCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_PORTCOUNT_RETURN(this, hrc, 9 /*unhandled exception*/,aPortCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setPortCount", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Bus)(StorageBus_T *aBus)
{
    LogRelFlow(("{%p} %s: enter aBus=%p\n", this, "StorageController::getBus", aBus));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBus);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBus(aBus);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 0 /*normal*/,*aBus);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 1 /*hrc exception*/,*aBus);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BUS_RETURN(this, hrc, 9 /*unhandled exception*/,*aBus);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBus=%RU32 hrc=%Rhrc\n", this, "StorageController::getBus", *aBus, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(ControllerType)(StorageControllerType_T *aControllerType)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%p\n", this, "StorageController::getControllerType", aControllerType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aControllerType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getControllerType(aControllerType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/,*aControllerType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aControllerType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_CONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aControllerType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aControllerType=%RU32 hrc=%Rhrc\n", this, "StorageController::getControllerType", *aControllerType, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(ControllerType)(StorageControllerType_T aControllerType)
{
    LogRelFlow(("{%p} %s: enter aControllerType=%RU32\n", this, "StorageController::setControllerType", aControllerType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_ENTER(this, aControllerType);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setControllerType(aControllerType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 0 /*normal*/,aControllerType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 1 /*hrc exception*/,aControllerType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_CONTROLLERTYPE_RETURN(this, hrc, 9 /*unhandled exception*/,aControllerType);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setControllerType", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(UseHostIOCache)(BOOL *aUseHostIOCache)
{
    LogRelFlow(("{%p} %s: enter aUseHostIOCache=%p\n", this, "StorageController::getUseHostIOCache", aUseHostIOCache));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUseHostIOCache);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUseHostIOCache(aUseHostIOCache);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 0 /*normal*/,*aUseHostIOCache != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 1 /*hrc exception*/,*aUseHostIOCache != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_USEHOSTIOCACHE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUseHostIOCache != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUseHostIOCache=%RTbool hrc=%Rhrc\n", this, "StorageController::getUseHostIOCache", *aUseHostIOCache, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMSETTER(UseHostIOCache)(BOOL aUseHostIOCache)
{
    LogRelFlow(("{%p} %s: enter aUseHostIOCache=%RTbool\n", this, "StorageController::setUseHostIOCache", aUseHostIOCache));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_ENTER(this, aUseHostIOCache != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setUseHostIOCache(aUseHostIOCache != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 0 /*normal*/,aUseHostIOCache != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 1 /*hrc exception*/,aUseHostIOCache != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_SET_USEHOSTIOCACHE_RETURN(this, hrc, 9 /*unhandled exception*/,aUseHostIOCache != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "StorageController::setUseHostIOCache", hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(Bootable)(BOOL *aBootable)
{
    LogRelFlow(("{%p} %s: enter aBootable=%p\n", this, "StorageController::getBootable", aBootable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBootable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBootable(aBootable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 0 /*normal*/,*aBootable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aBootable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STORAGECONTROLLER_GET_BOOTABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aBootable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aBootable=%RTbool hrc=%Rhrc\n", this, "StorageController::getBootable", *aBootable, hrc));
    return hrc;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute1IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute2IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute3IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute4IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute5IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute6IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute7IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::COMGETTER(InternalAndReservedAttribute8IStorageController)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IStorageController methods
//

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod1IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod2IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod3IStorageController()
{
    return E_NOTIMPL;
}

STDMETHODIMP StorageControllerWrap::InternalAndReservedMethod4IStorageController()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(StorageControllerWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(StorageControllerWrap, IStorageController)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "StorageControllerWrap.cpp"


// ##### BEGINFILE "PerformanceMetricWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IPerformanceMetric.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_PERFORMANCEMETRIC

#include "PerformanceMetricWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(PerformanceMetricWrap)

//
// IPerformanceMetric properties
//

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MetricName)(BSTR *aMetricName)
{
    LogRelFlow(("{%p} %s: enter aMetricName=%p\n", this, "PerformanceMetric::getMetricName", aMetricName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMetricName);
        BSTROutConverter TmpMetricName(aMetricName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMetricName(TmpMetricName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 0 /*normal*/,TmpMetricName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_METRICNAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMetricName=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getMetricName", *aMetricName, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Object)(IUnknown **aObject)
{
    LogRelFlow(("{%p} %s: enter aObject=%p\n", this, "PerformanceMetric::getObject", aObject));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aObject);
        ComTypeOutConverter<IUnknown> TmpObject(aObject);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getObject(TmpObject.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 0 /*normal*/,(void *)TmpObject.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_OBJECT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aObject=%p hrc=%Rhrc\n", this, "PerformanceMetric::getObject", *aObject, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "PerformanceMetric::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Period)(ULONG *aPeriod)
{
    LogRelFlow(("{%p} %s: enter aPeriod=%p\n", this, "PerformanceMetric::getPeriod", aPeriod));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPeriod);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPeriod(aPeriod);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 0 /*normal*/,*aPeriod);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 1 /*hrc exception*/,*aPeriod);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_PERIOD_RETURN(this, hrc, 9 /*unhandled exception*/,*aPeriod);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPeriod=%RU32 hrc=%Rhrc\n", this, "PerformanceMetric::getPeriod", *aPeriod, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Count)(ULONG *aCount)
{
    LogRelFlow(("{%p} %s: enter aCount=%p\n", this, "PerformanceMetric::getCount", aCount));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aCount);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getCount(aCount);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 0 /*normal*/,*aCount);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 1 /*hrc exception*/,*aCount);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_COUNT_RETURN(this, hrc, 9 /*unhandled exception*/,*aCount);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aCount=%RU32 hrc=%Rhrc\n", this, "PerformanceMetric::getCount", *aCount, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(Unit)(BSTR *aUnit)
{
    LogRelFlow(("{%p} %s: enter aUnit=%p\n", this, "PerformanceMetric::getUnit", aUnit));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUnit);
        BSTROutConverter TmpUnit(aUnit);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUnit(TmpUnit.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 0 /*normal*/,TmpUnit.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_UNIT_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUnit=%ls hrc=%Rhrc\n", this, "PerformanceMetric::getUnit", *aUnit, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MinimumValue)(LONG *aMinimumValue)
{
    LogRelFlow(("{%p} %s: enter aMinimumValue=%p\n", this, "PerformanceMetric::getMinimumValue", aMinimumValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMinimumValue);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMinimumValue(aMinimumValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 0 /*normal*/,*aMinimumValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 1 /*hrc exception*/,*aMinimumValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MINIMUMVALUE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMinimumValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMinimumValue=%RI32 hrc=%Rhrc\n", this, "PerformanceMetric::getMinimumValue", *aMinimumValue, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(MaximumValue)(LONG *aMaximumValue)
{
    LogRelFlow(("{%p} %s: enter aMaximumValue=%p\n", this, "PerformanceMetric::getMaximumValue", aMaximumValue));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMaximumValue);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMaximumValue(aMaximumValue);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 0 /*normal*/,*aMaximumValue);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 1 /*hrc exception*/,*aMaximumValue);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_PERFORMANCEMETRIC_GET_MAXIMUMVALUE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMaximumValue);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMaximumValue=%RI32 hrc=%Rhrc\n", this, "PerformanceMetric::getMaximumValue", *aMaximumValue, hrc));
    return hrc;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute1IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute2IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute3IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute4IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute5IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute6IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute7IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP PerformanceMetricWrap::COMGETTER(InternalAndReservedAttribute8IPerformanceMetric)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IPerformanceMetric methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(PerformanceMetricWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceMetricWrap, IPerformanceMetric)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "PerformanceMetricWrap.cpp"


// ##### BEGINFILE "NATEngineWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for INATEngine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_NATENGINE

#include "NATEngineWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(NATEngineWrap)

//
// INATEngine properties
//

STDMETHODIMP NATEngineWrap::COMGETTER(Network)(BSTR *aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%p\n", this, "NATEngine::getNetwork", aNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNetwork);
        BSTROutConverter TmpNetwork(aNetwork);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetwork(TmpNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNetwork=%ls hrc=%Rhrc\n", this, "NATEngine::getNetwork", *aNetwork, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(Network)(IN_BSTR aNetwork)
{
    LogRelFlow(("{%p} %s: enter aNetwork=%ls\n", this, "NATEngine::setNetwork", aNetwork));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpNetwork(aNetwork);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_ENTER(this, TmpNetwork.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetwork(TmpNetwork.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 0 /*normal*/,TmpNetwork.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_NETWORK_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setNetwork", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(HostIP)(BSTR *aHostIP)
{
    LogRelFlow(("{%p} %s: enter aHostIP=%p\n", this, "NATEngine::getHostIP", aHostIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHostIP);
        BSTROutConverter TmpHostIP(aHostIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHostIP(TmpHostIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 0 /*normal*/,TmpHostIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_HOSTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHostIP=%ls hrc=%Rhrc\n", this, "NATEngine::getHostIP", *aHostIP, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(HostIP)(IN_BSTR aHostIP)
{
    LogRelFlow(("{%p} %s: enter aHostIP=%ls\n", this, "NATEngine::setHostIP", aHostIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpHostIP(aHostIP);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_ENTER(this, TmpHostIP.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setHostIP(TmpHostIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 0 /*normal*/,TmpHostIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_HOSTIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setHostIP", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPPrefix)(BSTR *aTFTPPrefix)
{
    LogRelFlow(("{%p} %s: enter aTFTPPrefix=%p\n", this, "NATEngine::getTFTPPrefix", aTFTPPrefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPPrefix);
        BSTROutConverter TmpTFTPPrefix(aTFTPPrefix);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPPrefix(TmpTFTPPrefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 0 /*normal*/,TmpTFTPPrefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPPREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPPrefix=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPPrefix", *aTFTPPrefix, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPPrefix)(IN_BSTR aTFTPPrefix)
{
    LogRelFlow(("{%p} %s: enter aTFTPPrefix=%ls\n", this, "NATEngine::setTFTPPrefix", aTFTPPrefix));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPPrefix(aTFTPPrefix);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_ENTER(this, TmpTFTPPrefix.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPPrefix(TmpTFTPPrefix.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 0 /*normal*/,TmpTFTPPrefix.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPPREFIX_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPPrefix", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPBootFile)(BSTR *aTFTPBootFile)
{
    LogRelFlow(("{%p} %s: enter aTFTPBootFile=%p\n", this, "NATEngine::getTFTPBootFile", aTFTPBootFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPBootFile);
        BSTROutConverter TmpTFTPBootFile(aTFTPBootFile);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPBootFile(TmpTFTPBootFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 0 /*normal*/,TmpTFTPBootFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPBOOTFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPBootFile=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPBootFile", *aTFTPBootFile, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPBootFile)(IN_BSTR aTFTPBootFile)
{
    LogRelFlow(("{%p} %s: enter aTFTPBootFile=%ls\n", this, "NATEngine::setTFTPBootFile", aTFTPBootFile));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPBootFile(aTFTPBootFile);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_ENTER(this, TmpTFTPBootFile.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPBootFile(TmpTFTPBootFile.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 0 /*normal*/,TmpTFTPBootFile.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPBOOTFILE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPBootFile", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(TFTPNextServer)(BSTR *aTFTPNextServer)
{
    LogRelFlow(("{%p} %s: enter aTFTPNextServer=%p\n", this, "NATEngine::getTFTPNextServer", aTFTPNextServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aTFTPNextServer);
        BSTROutConverter TmpTFTPNextServer(aTFTPNextServer);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getTFTPNextServer(TmpTFTPNextServer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 0 /*normal*/,TmpTFTPNextServer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_TFTPNEXTSERVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aTFTPNextServer=%ls hrc=%Rhrc\n", this, "NATEngine::getTFTPNextServer", *aTFTPNextServer, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(TFTPNextServer)(IN_BSTR aTFTPNextServer)
{
    LogRelFlow(("{%p} %s: enter aTFTPNextServer=%ls\n", this, "NATEngine::setTFTPNextServer", aTFTPNextServer));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        BSTRInConverter TmpTFTPNextServer(aTFTPNextServer);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_ENTER(this, TmpTFTPNextServer.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setTFTPNextServer(TmpTFTPNextServer.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 0 /*normal*/,TmpTFTPNextServer.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_TFTPNEXTSERVER_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setTFTPNextServer", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(AliasMode)(ULONG *aAliasMode)
{
    LogRelFlow(("{%p} %s: enter aAliasMode=%p\n", this, "NATEngine::getAliasMode", aAliasMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aAliasMode);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAliasMode(aAliasMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 0 /*normal*/,*aAliasMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 1 /*hrc exception*/,*aAliasMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_ALIASMODE_RETURN(this, hrc, 9 /*unhandled exception*/,*aAliasMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aAliasMode=%RU32 hrc=%Rhrc\n", this, "NATEngine::getAliasMode", *aAliasMode, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(AliasMode)(ULONG aAliasMode)
{
    LogRelFlow(("{%p} %s: enter aAliasMode=%RU32\n", this, "NATEngine::setAliasMode", aAliasMode));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_ENTER(this, aAliasMode);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setAliasMode(aAliasMode);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 0 /*normal*/,aAliasMode);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 1 /*hrc exception*/,aAliasMode);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_ALIASMODE_RETURN(this, hrc, 9 /*unhandled exception*/,aAliasMode);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setAliasMode", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSPassDomain)(BOOL *aDNSPassDomain)
{
    LogRelFlow(("{%p} %s: enter aDNSPassDomain=%p\n", this, "NATEngine::getDNSPassDomain", aDNSPassDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSPassDomain);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSPassDomain(aDNSPassDomain);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 0 /*normal*/,*aDNSPassDomain != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSPassDomain != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPASSDOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSPassDomain != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSPassDomain=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSPassDomain", *aDNSPassDomain, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSPassDomain)(BOOL aDNSPassDomain)
{
    LogRelFlow(("{%p} %s: enter aDNSPassDomain=%RTbool\n", this, "NATEngine::setDNSPassDomain", aDNSPassDomain));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_ENTER(this, aDNSPassDomain != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSPassDomain(aDNSPassDomain != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 0 /*normal*/,aDNSPassDomain != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 1 /*hrc exception*/,aDNSPassDomain != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPASSDOMAIN_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSPassDomain != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSPassDomain", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSProxy)(BOOL *aDNSProxy)
{
    LogRelFlow(("{%p} %s: enter aDNSProxy=%p\n", this, "NATEngine::getDNSProxy", aDNSProxy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSProxy);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSProxy(aDNSProxy);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 0 /*normal*/,*aDNSProxy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSProxy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSPROXY_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSProxy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSProxy=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSProxy", *aDNSProxy, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSProxy)(BOOL aDNSProxy)
{
    LogRelFlow(("{%p} %s: enter aDNSProxy=%RTbool\n", this, "NATEngine::setDNSProxy", aDNSProxy));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_ENTER(this, aDNSProxy != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSProxy(aDNSProxy != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 0 /*normal*/,aDNSProxy != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 1 /*hrc exception*/,aDNSProxy != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSPROXY_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSProxy != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSProxy", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(DNSUseHostResolver)(BOOL *aDNSUseHostResolver)
{
    LogRelFlow(("{%p} %s: enter aDNSUseHostResolver=%p\n", this, "NATEngine::getDNSUseHostResolver", aDNSUseHostResolver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDNSUseHostResolver);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDNSUseHostResolver(aDNSUseHostResolver);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 0 /*normal*/,*aDNSUseHostResolver != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 1 /*hrc exception*/,*aDNSUseHostResolver != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 9 /*unhandled exception*/,*aDNSUseHostResolver != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDNSUseHostResolver=%RTbool hrc=%Rhrc\n", this, "NATEngine::getDNSUseHostResolver", *aDNSUseHostResolver, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMSETTER(DNSUseHostResolver)(BOOL aDNSUseHostResolver)
{
    LogRelFlow(("{%p} %s: enter aDNSUseHostResolver=%RTbool\n", this, "NATEngine::setDNSUseHostResolver", aDNSUseHostResolver));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_ENTER(this, aDNSUseHostResolver != FALSE);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setDNSUseHostResolver(aDNSUseHostResolver != FALSE);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 0 /*normal*/,aDNSUseHostResolver != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 1 /*hrc exception*/,aDNSUseHostResolver != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SET_DNSUSEHOSTRESOLVER_RETURN(this, hrc, 9 /*unhandled exception*/,aDNSUseHostResolver != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setDNSUseHostResolver", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(Redirects)(ComSafeArrayOut(BSTR, aRedirects))
{
    LogRelFlow(("{%p} %s: enter aRedirects=%p\n", this, "NATEngine::getRedirects", aRedirects));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRedirects);
        ArrayBSTROutConverter TmpRedirects(ComSafeArrayOutArg(aRedirects));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRedirects(TmpRedirects.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpRedirects.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GET_REDIRECTS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRedirects=%zu hrc=%Rhrc\n", this, "NATEngine::getRedirects", ComSafeArraySize(*aRedirects), hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute1INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute2INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute3INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute4INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute5INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute6INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute7INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::COMGETTER(InternalAndReservedAttribute8INATEngine)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// INATEngine methods
//

STDMETHODIMP NATEngineWrap::SetNetworkSettings(ULONG aMtu,
                                               ULONG aSockSnd,
                                               ULONG aSockRcv,
                                               ULONG aTcpWndSnd,
                                               ULONG aTcpWndRcv)
{
    LogRelFlow(("{%p} %s:enter aMtu=%RU32 aSockSnd=%RU32 aSockRcv=%RU32 aTcpWndSnd=%RU32 aTcpWndRcv=%RU32\n", this, "NATEngine::setNetworkSettings", aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_ENTER(this, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setNetworkSettings(aMtu,
                                     aSockSnd,
                                     aSockRcv,
                                     aTcpWndSnd,
                                     aTcpWndRcv);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 0 /*normal*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_SETNETWORKSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::setNetworkSettings", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::GetNetworkSettings(ULONG *aMtu,
                                               ULONG *aSockSnd,
                                               ULONG *aSockRcv,
                                               ULONG *aTcpWndSnd,
                                               ULONG *aTcpWndRcv)
{
    LogRelFlow(("{%p} %s:enter aMtu=%p aSockSnd=%p aSockRcv=%p aTcpWndSnd=%p aTcpWndRcv=%p\n", this, "NATEngine::getNetworkSettings", aMtu, aSockSnd, aSockRcv, aTcpWndSnd, aTcpWndRcv));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMtu);
        CheckComArgOutPointerValidThrow(aSockSnd);
        CheckComArgOutPointerValidThrow(aSockRcv);
        CheckComArgOutPointerValidThrow(aTcpWndSnd);
        CheckComArgOutPointerValidThrow(aTcpWndRcv);


        
        
        
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNetworkSettings(aMtu,
                                     aSockSnd,
                                     aSockRcv,
                                     aTcpWndSnd,
                                     aTcpWndRcv);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 0 /*normal*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 1 /*hrc exception*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_GETNETWORKSETTINGS_RETURN(this, hrc, 9 /*unhandled exception*/, *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMtu=%RU32 *aSockSnd=%RU32 *aSockRcv=%RU32 *aTcpWndSnd=%RU32 *aTcpWndRcv=%RU32 hrc=%Rhrc\n", this, "NATEngine::getNetworkSettings", *aMtu, *aSockSnd, *aSockRcv, *aTcpWndSnd, *aTcpWndRcv, hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::AddRedirect(IN_BSTR aName,
                                        NATProtocol_T aProto,
                                        IN_BSTR aHostIP,
                                        USHORT aHostPort,
                                        IN_BSTR aGuestIP,
                                        USHORT aGuestPort)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aProto=%RU32 aHostIP=%ls aHostPort=%RU16 aGuestIP=%ls aGuestPort=%RU16\n", this, "NATEngine::addRedirect", aName, aProto, aHostIP, aHostPort, aGuestIP, aGuestPort));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        BSTRInConverter TmpHostIP(aHostIP);
        
        BSTRInConverter TmpGuestIP(aGuestIP);
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_ENTER(this, TmpName.str().c_str(), aProto, TmpHostIP.str().c_str(), aHostPort, TmpGuestIP.str().c_str(), aGuestPort);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addRedirect(TmpName.str(),
                              aProto,
                              TmpHostIP.str(),
                              aHostPort,
                              TmpGuestIP.str(),
                              aGuestPort);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aProto, TmpHostIP.str().c_str(), aHostPort, TmpGuestIP.str().c_str(), aGuestPort);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 1 /*hrc exception*/, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_ADDREDIRECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aProto, 0, aHostPort, 0, aGuestPort);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::addRedirect", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::RemoveRedirect(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s:enter aName=%ls\n", this, "NATEngine::removeRedirect", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = removeRedirect(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_NATENGINE_REMOVEREDIRECT_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "NATEngine::removeRedirect", hrc));
    return hrc;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod1INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod2INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod3INATEngine()
{
    return E_NOTIMPL;
}

STDMETHODIMP NATEngineWrap::InternalAndReservedMethod4INATEngine()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(NATEngineWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NATEngineWrap, INATEngine)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "NATEngineWrap.cpp"


// ##### BEGINFILE "ExtPackBaseWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackBase.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_EXTPACKBASE

#include "ExtPackBaseWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackBaseWrap)

//
// IExtPackBase properties
//

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPackBase::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPackBase::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPackBase::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPackBase::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "ExtPackBase::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "ExtPackBase::getVersion", *aVersion, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPackBase::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPackBase::getRevision", *aRevision, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Edition)(BSTR *aEdition)
{
    LogRelFlow(("{%p} %s: enter aEdition=%p\n", this, "ExtPackBase::getEdition", aEdition));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEdition);
        BSTROutConverter TmpEdition(aEdition);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEdition(TmpEdition.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 0 /*normal*/,TmpEdition.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_EDITION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEdition=%ls hrc=%Rhrc\n", this, "ExtPackBase::getEdition", *aEdition, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(VRDEModule)(BSTR *aVRDEModule)
{
    LogRelFlow(("{%p} %s: enter aVRDEModule=%p\n", this, "ExtPackBase::getVRDEModule", aVRDEModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEModule);
        BSTROutConverter TmpVRDEModule(aVRDEModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEModule(TmpVRDEModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 0 /*normal*/,TmpVRDEModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_VRDEMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEModule=%ls hrc=%Rhrc\n", this, "ExtPackBase::getVRDEModule", *aVRDEModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(PlugIns)(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns))
{
    LogRelFlow(("{%p} %s: enter aPlugIns=%p\n", this, "ExtPackBase::getPlugIns", aPlugIns));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugIns);
        ArrayComTypeOutConverter<IExtPackPlugIn> TmpPlugIns(ComSafeArrayOutArg(aPlugIns));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlugIns(TmpPlugIns.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPlugIns.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_PLUGINS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlugIns=%zu hrc=%Rhrc\n", this, "ExtPackBase::getPlugIns", ComSafeArraySize(*aPlugIns), hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(Usable)(BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aUsable=%p\n", this, "ExtPackBase::getUsable", aUsable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUsable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsable(aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 0 /*normal*/,*aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aUsable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_USABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPackBase::getUsable", *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(WhyUnusable)(BSTR *aWhyUnusable)
{
    LogRelFlow(("{%p} %s: enter aWhyUnusable=%p\n", this, "ExtPackBase::getWhyUnusable", aWhyUnusable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWhyUnusable);
        BSTROutConverter TmpWhyUnusable(aWhyUnusable);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWhyUnusable(TmpWhyUnusable.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 0 /*normal*/,TmpWhyUnusable.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_WHYUNUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWhyUnusable=%ls hrc=%Rhrc\n", this, "ExtPackBase::getWhyUnusable", *aWhyUnusable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(ShowLicense)(BOOL *aShowLicense)
{
    LogRelFlow(("{%p} %s: enter aShowLicense=%p\n", this, "ExtPackBase::getShowLicense", aShowLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShowLicense);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShowLicense(aShowLicense);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 0 /*normal*/,*aShowLicense != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 1 /*hrc exception*/,*aShowLicense != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_SHOWLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,*aShowLicense != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShowLicense=%RTbool hrc=%Rhrc\n", this, "ExtPackBase::getShowLicense", *aShowLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(License)(BSTR *aLicense)
{
    LogRelFlow(("{%p} %s: enter aLicense=%p\n", this, "ExtPackBase::getLicense", aLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicense);
        BSTROutConverter TmpLicense(aLicense);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLicense(TmpLicense.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 0 /*normal*/,TmpLicense.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_GET_LICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLicense=%ls hrc=%Rhrc\n", this, "ExtPackBase::getLicense", *aLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute1IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute2IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute3IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute4IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute5IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute6IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute7IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::COMGETTER(InternalAndReservedAttribute8IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackBase methods
//

STDMETHODIMP ExtPackBaseWrap::QueryLicense(IN_BSTR aPreferredLocale,
                                           IN_BSTR aPreferredLanguage,
                                           IN_BSTR aFormat,
                                           BSTR *aLicenseText)
{
    LogRelFlow(("{%p} %s:enter aPreferredLocale=%ls aPreferredLanguage=%ls aFormat=%ls aLicenseText=%p\n", this, "ExtPackBase::queryLicense", aPreferredLocale, aPreferredLanguage, aFormat, aLicenseText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicenseText);


        BSTRInConverter TmpPreferredLocale(aPreferredLocale);
        BSTRInConverter TmpPreferredLanguage(aPreferredLanguage);
        BSTRInConverter TmpFormat(aFormat);
        BSTROutConverter TmpLicenseText(aLicenseText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_ENTER(this, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryLicense(TmpPreferredLocale.str(),
                               TmpPreferredLanguage.str(),
                               TmpFormat.str(),
                               TmpLicenseText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 0 /*normal*/, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str(), TmpLicenseText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKBASE_QUERYLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLicenseText=%ls hrc=%Rhrc\n", this, "ExtPackBase::queryLicense", *aLicenseText, hrc));
    return hrc;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod1IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod2IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod3IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackBaseWrap::InternalAndReservedMethod4IExtPackBase()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackBaseWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackBaseWrap, IExtPackBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackBaseWrap.cpp"


// ##### BEGINFILE "ExtPackFileWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IExtPackFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_EXTPACKFILE

#include "ExtPackFileWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(ExtPackFileWrap)

//
// IExtPackBase properties
//

STDMETHODIMP ExtPackFileWrap::COMGETTER(Name)(BSTR *aName)
{
    LogRelFlow(("{%p} %s: enter aName=%p\n", this, "ExtPackFile::getName", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aName);
        BSTROutConverter TmpName(aName);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getName(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 0 /*normal*/,TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_NAME_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aName=%ls hrc=%Rhrc\n", this, "ExtPackFile::getName", *aName, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "ExtPackFile::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "ExtPackFile::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Version)(BSTR *aVersion)
{
    LogRelFlow(("{%p} %s: enter aVersion=%p\n", this, "ExtPackFile::getVersion", aVersion));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVersion);
        BSTROutConverter TmpVersion(aVersion);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVersion(TmpVersion.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 0 /*normal*/,TmpVersion.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VERSION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVersion=%ls hrc=%Rhrc\n", this, "ExtPackFile::getVersion", *aVersion, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Revision)(ULONG *aRevision)
{
    LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPackFile::getRevision", aRevision));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aRevision);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getRevision(aRevision);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 0 /*normal*/,*aRevision);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 1 /*hrc exception*/,*aRevision);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_REVISION_RETURN(this, hrc, 9 /*unhandled exception*/,*aRevision);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPackFile::getRevision", *aRevision, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Edition)(BSTR *aEdition)
{
    LogRelFlow(("{%p} %s: enter aEdition=%p\n", this, "ExtPackFile::getEdition", aEdition));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEdition);
        BSTROutConverter TmpEdition(aEdition);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEdition(TmpEdition.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 0 /*normal*/,TmpEdition.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_EDITION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEdition=%ls hrc=%Rhrc\n", this, "ExtPackFile::getEdition", *aEdition, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(VRDEModule)(BSTR *aVRDEModule)
{
    LogRelFlow(("{%p} %s: enter aVRDEModule=%p\n", this, "ExtPackFile::getVRDEModule", aVRDEModule));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVRDEModule);
        BSTROutConverter TmpVRDEModule(aVRDEModule);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVRDEModule(TmpVRDEModule.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 0 /*normal*/,TmpVRDEModule.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_VRDEMODULE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVRDEModule=%ls hrc=%Rhrc\n", this, "ExtPackFile::getVRDEModule", *aVRDEModule, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(PlugIns)(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns))
{
    LogRelFlow(("{%p} %s: enter aPlugIns=%p\n", this, "ExtPackFile::getPlugIns", aPlugIns));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPlugIns);
        ArrayComTypeOutConverter<IExtPackPlugIn> TmpPlugIns(ComSafeArrayOutArg(aPlugIns));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPlugIns(TmpPlugIns.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpPlugIns.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_PLUGINS_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPlugIns=%zu hrc=%Rhrc\n", this, "ExtPackFile::getPlugIns", ComSafeArraySize(*aPlugIns), hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(Usable)(BOOL *aUsable)
{
    LogRelFlow(("{%p} %s: enter aUsable=%p\n", this, "ExtPackFile::getUsable", aUsable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aUsable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getUsable(aUsable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 0 /*normal*/,*aUsable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aUsable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_USABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aUsable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aUsable=%RTbool hrc=%Rhrc\n", this, "ExtPackFile::getUsable", *aUsable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(WhyUnusable)(BSTR *aWhyUnusable)
{
    LogRelFlow(("{%p} %s: enter aWhyUnusable=%p\n", this, "ExtPackFile::getWhyUnusable", aWhyUnusable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWhyUnusable);
        BSTROutConverter TmpWhyUnusable(aWhyUnusable);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWhyUnusable(TmpWhyUnusable.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 0 /*normal*/,TmpWhyUnusable.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_WHYUNUSABLE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWhyUnusable=%ls hrc=%Rhrc\n", this, "ExtPackFile::getWhyUnusable", *aWhyUnusable, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(ShowLicense)(BOOL *aShowLicense)
{
    LogRelFlow(("{%p} %s: enter aShowLicense=%p\n", this, "ExtPackFile::getShowLicense", aShowLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aShowLicense);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getShowLicense(aShowLicense);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 0 /*normal*/,*aShowLicense != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 1 /*hrc exception*/,*aShowLicense != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_SHOWLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,*aShowLicense != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aShowLicense=%RTbool hrc=%Rhrc\n", this, "ExtPackFile::getShowLicense", *aShowLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(License)(BSTR *aLicense)
{
    LogRelFlow(("{%p} %s: enter aLicense=%p\n", this, "ExtPackFile::getLicense", aLicense));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicense);
        BSTROutConverter TmpLicense(aLicense);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLicense(TmpLicense.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 0 /*normal*/,TmpLicense.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_LICENSE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLicense=%ls hrc=%Rhrc\n", this, "ExtPackFile::getLicense", *aLicense, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute1IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute2IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute3IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute4IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute5IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute6IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute7IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute8IExtPackBase)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IExtPackFile properties
//

STDMETHODIMP ExtPackFileWrap::COMGETTER(FilePath)(BSTR *aFilePath)
{
    LogRelFlow(("{%p} %s: enter aFilePath=%p\n", this, "ExtPackFile::getFilePath", aFilePath));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aFilePath);
        BSTROutConverter TmpFilePath(aFilePath);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getFilePath(TmpFilePath.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 0 /*normal*/,TmpFilePath.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_GET_FILEPATH_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aFilePath=%ls hrc=%Rhrc\n", this, "ExtPackFile::getFilePath", *aFilePath, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute1IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute2IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute3IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::COMGETTER(InternalAndReservedAttribute4IExtPackFile)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IExtPackBase methods
//

STDMETHODIMP ExtPackFileWrap::QueryLicense(IN_BSTR aPreferredLocale,
                                           IN_BSTR aPreferredLanguage,
                                           IN_BSTR aFormat,
                                           BSTR *aLicenseText)
{
    LogRelFlow(("{%p} %s:enter aPreferredLocale=%ls aPreferredLanguage=%ls aFormat=%ls aLicenseText=%p\n", this, "ExtPackFile::queryLicense", aPreferredLocale, aPreferredLanguage, aFormat, aLicenseText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLicenseText);


        BSTRInConverter TmpPreferredLocale(aPreferredLocale);
        BSTRInConverter TmpPreferredLanguage(aPreferredLanguage);
        BSTRInConverter TmpFormat(aFormat);
        BSTROutConverter TmpLicenseText(aLicenseText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_ENTER(this, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = queryLicense(TmpPreferredLocale.str(),
                               TmpPreferredLanguage.str(),
                               TmpFormat.str(),
                               TmpLicenseText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 0 /*normal*/, TmpPreferredLocale.str().c_str(), TmpPreferredLanguage.str().c_str(), TmpFormat.str().c_str(), TmpLicenseText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_QUERYLICENSE_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aLicenseText=%ls hrc=%Rhrc\n", this, "ExtPackFile::queryLicense", *aLicenseText, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod1IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod2IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod3IExtPackBase()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod4IExtPackBase()
{
    return E_NOTIMPL;
}

//
// IExtPackFile methods
//

STDMETHODIMP ExtPackFileWrap::Install(BOOL aReplace,
                                      IN_BSTR aDisplayInfo,
                                      IProgress **aProgess)
{
    LogRelFlow(("{%p} %s:enter aReplace=%RTbool aDisplayInfo=%ls aProgess=%p\n", this, "ExtPackFile::install", aReplace, aDisplayInfo, aProgess));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgess);


        
        BSTRInConverter TmpDisplayInfo(aDisplayInfo);
        ComTypeOutConverter<IProgress> TmpProgess(aProgess);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_ENTER(this, aReplace != FALSE, TmpDisplayInfo.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = install(aReplace != FALSE,
                          TmpDisplayInfo.str(),
                          TmpProgess.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 0 /*normal*/, aReplace != FALSE, TmpDisplayInfo.str().c_str(), (void *)TmpProgess.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 1 /*hrc exception*/, aReplace != FALSE, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_EXTPACKFILE_INSTALL_RETURN(this, hrc, 9 /*unhandled exception*/, aReplace != FALSE, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgess=%p hrc=%Rhrc\n", this, "ExtPackFile::install", *aProgess, hrc));
    return hrc;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod1IExtPackFile()
{
    return E_NOTIMPL;
}

STDMETHODIMP ExtPackFileWrap::InternalAndReservedMethod2IExtPackFile()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(ExtPackFileWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ExtPackFileWrap, IExtPackFile, IExtPackBase)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "ExtPackFileWrap.cpp"


// ##### BEGINFILE "BandwidthControlWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IBandwidthControl.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_BANDWIDTHCONTROL

#include "BandwidthControlWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(BandwidthControlWrap)

//
// IBandwidthControl properties
//

STDMETHODIMP BandwidthControlWrap::COMGETTER(NumGroups)(ULONG *aNumGroups)
{
    LogRelFlow(("{%p} %s: enter aNumGroups=%p\n", this, "BandwidthControl::getNumGroups", aNumGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aNumGroups);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getNumGroups(aNumGroups);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 0 /*normal*/,*aNumGroups);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 1 /*hrc exception*/,*aNumGroups);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GET_NUMGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/,*aNumGroups);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aNumGroups=%RU32 hrc=%Rhrc\n", this, "BandwidthControl::getNumGroups", *aNumGroups, hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::COMGETTER(InternalAndReservedAttribute1IBandwidthControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthControlWrap::COMGETTER(InternalAndReservedAttribute2IBandwidthControl)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IBandwidthControl methods
//

STDMETHODIMP BandwidthControlWrap::CreateBandwidthGroup(IN_BSTR aName,
                                                        BandwidthGroupType_T aType,
                                                        LONG64 aMaxBytesPerSec)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aType=%RU32 aMaxBytesPerSec=%RI64\n", this, "BandwidthControl::createBandwidthGroup", aName, aType, aMaxBytesPerSec));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);
        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str(), aType, aMaxBytesPerSec);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = createBandwidthGroup(TmpName.str(),
                                       aType,
                                       aMaxBytesPerSec);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), aType, aMaxBytesPerSec);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0, aType, aMaxBytesPerSec);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_CREATEBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, aType, aMaxBytesPerSec);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "BandwidthControl::createBandwidthGroup", hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::DeleteBandwidthGroup(IN_BSTR aName)
{
    LogRelFlow(("{%p} %s:enter aName=%ls\n", this, "BandwidthControl::deleteBandwidthGroup", aName));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpName(aName);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = deleteBandwidthGroup(TmpName.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_DELETEBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "BandwidthControl::deleteBandwidthGroup", hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::GetBandwidthGroup(IN_BSTR aName,
                                                     IBandwidthGroup **aBandwidthGroup)
{
    LogRelFlow(("{%p} %s:enter aName=%ls aBandwidthGroup=%p\n", this, "BandwidthControl::getBandwidthGroup", aName, aBandwidthGroup));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroup);


        BSTRInConverter TmpName(aName);
        ComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroup(aBandwidthGroup);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_ENTER(this, TmpName.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getBandwidthGroup(TmpName.str(),
                                    TmpBandwidthGroup.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 0 /*normal*/, TmpName.str().c_str(), (void *)TmpBandwidthGroup.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETBANDWIDTHGROUP_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBandwidthGroup=%p hrc=%Rhrc\n", this, "BandwidthControl::getBandwidthGroup", *aBandwidthGroup, hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::GetAllBandwidthGroups(ComSafeArrayOut(IBandwidthGroup *, aBandwidthGroups))
{
    LogRelFlow(("{%p} %s:enter aBandwidthGroups=%p\n", this, "BandwidthControl::getAllBandwidthGroups", aBandwidthGroups));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aBandwidthGroups);


        ArrayComTypeOutConverter<IBandwidthGroup> TmpBandwidthGroups(ComSafeArrayOutArg(aBandwidthGroups));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getAllBandwidthGroups(TmpBandwidthGroups.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpBandwidthGroups.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_BANDWIDTHCONTROL_GETALLBANDWIDTHGROUPS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aBandwidthGroups=%zu hrc=%Rhrc\n", this, "BandwidthControl::getAllBandwidthGroups", ComSafeArraySize(*aBandwidthGroups), hrc));
    return hrc;
}

STDMETHODIMP BandwidthControlWrap::InternalAndReservedMethod1IBandwidthControl()
{
    return E_NOTIMPL;
}

STDMETHODIMP BandwidthControlWrap::InternalAndReservedMethod2IBandwidthControl()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(BandwidthControlWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BandwidthControlWrap, IBandwidthControl)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "BandwidthControlWrap.cpp"


// ##### BEGINFILE "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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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", *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.rc();
        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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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", *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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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.rc();
        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", *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 "VetoEventWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IVetoEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_VETOEVENT

#include "VetoEventWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(VetoEventWrap)

//
// IEvent properties
//

STDMETHODIMP VetoEventWrap::COMGETTER(Type)(VBoxEventType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "VetoEvent::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "VetoEvent::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::COMGETTER(Source)(IEventSource **aSource)
{
    LogRelFlow(("{%p} %s: enter aSource=%p\n", this, "VetoEvent::getSource", aSource));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSource);
        ComTypeOutConverter<IEventSource> TmpSource(aSource);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSource(TmpSource.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 0 /*normal*/,(void *)TmpSource.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_SOURCE_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSource=%p hrc=%Rhrc\n", this, "VetoEvent::getSource", *aSource, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::COMGETTER(Waitable)(BOOL *aWaitable)
{
    LogRelFlow(("{%p} %s: enter aWaitable=%p\n", this, "VetoEvent::getWaitable", aWaitable));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aWaitable);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getWaitable(aWaitable);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 0 /*normal*/,*aWaitable != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 1 /*hrc exception*/,*aWaitable != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GET_WAITABLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aWaitable != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aWaitable=%RTbool hrc=%Rhrc\n", this, "VetoEvent::getWaitable", *aWaitable, hrc));
    return hrc;
}

//
// IVetoEvent properties
//


//
// IEvent methods
//

STDMETHODIMP VetoEventWrap::SetProcessed()
{
    LogRelFlow(("{%p} %s:enter\n", this, "VetoEvent::setProcessed"));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {



#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setProcessed();
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 0 /*normal*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_SETPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::setProcessed", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::WaitProcessed(LONG aTimeout,
                                          BOOL *aResult)
{
    LogRelFlow(("{%p} %s:enter aTimeout=%RI32 aResult=%p\n", this, "VetoEvent::waitProcessed", aTimeout, aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        
        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_ENTER(this, aTimeout);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = waitProcessed(aTimeout,
                                aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 0 /*normal*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 1 /*hrc exception*/, aTimeout, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_WAITPROCESSED_RETURN(this, hrc, 9 /*unhandled exception*/, aTimeout, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::waitProcessed", *aResult, hrc));
    return hrc;
}

//
// IVetoEvent methods
//

STDMETHODIMP VetoEventWrap::AddVeto(IN_BSTR aReason)
{
    LogRelFlow(("{%p} %s:enter aReason=%ls\n", this, "VetoEvent::addVeto", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpReason(aReason);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_ENTER(this, TmpReason.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addVeto(TmpReason.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 0 /*normal*/, TmpReason.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDVETO_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::addVeto", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::IsVetoed(BOOL *aResult)
{
    LogRelFlow(("{%p} %s:enter aResult=%p\n", this, "VetoEvent::isVetoed", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = isVetoed(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISVETOED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::isVetoed", *aResult, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::GetVetos(ComSafeArrayOut(BSTR, aResult))
{
    LogRelFlow(("{%p} %s:enter aResult=%p\n", this, "VetoEvent::getVetos", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayBSTROutConverter TmpResult(ComSafeArrayOutArg(aResult));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVetos(TmpResult.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpResult.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETVETOS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%zu hrc=%Rhrc\n", this, "VetoEvent::getVetos", ComSafeArraySize(*aResult), hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::AddApproval(IN_BSTR aReason)
{
    LogRelFlow(("{%p} %s:enter aReason=%ls\n", this, "VetoEvent::addApproval", aReason));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {


        BSTRInConverter TmpReason(aReason);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_ENTER(this, TmpReason.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = addApproval(TmpReason.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 0 /*normal*/, TmpReason.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ADDAPPROVAL_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "VetoEvent::addApproval", hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::IsApproved(BOOL *aResult)
{
    LogRelFlow(("{%p} %s:enter aResult=%p\n", this, "VetoEvent::isApproved", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = isApproved(aResult);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 0 /*normal*/, *aResult != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 1 /*hrc exception*/, *aResult != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_ISAPPROVED_RETURN(this, hrc, 9 /*unhandled exception*/, *aResult != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%RTbool hrc=%Rhrc\n", this, "VetoEvent::isApproved", *aResult, hrc));
    return hrc;
}

STDMETHODIMP VetoEventWrap::GetApprovals(ComSafeArrayOut(BSTR, aResult))
{
    LogRelFlow(("{%p} %s:enter aResult=%p\n", this, "VetoEvent::getApprovals", aResult));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aResult);


        ArrayBSTROutConverter TmpResult(ComSafeArrayOutArg(aResult));

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getApprovals(TmpResult.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 0 /*normal*/, (uint32_t)TmpResult.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_VETOEVENT_GETAPPROVALS_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aResult=%zu hrc=%Rhrc\n", this, "VetoEvent::getApprovals", ComSafeArraySize(*aResult), hrc));
    return hrc;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(VetoEventWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(VetoEventWrap, IVetoEvent, IEvent)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "VetoEventWrap.cpp"


// ##### BEGINFILE "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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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 "StringFormValueWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IStringFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_STRINGFORMVALUE

#include "StringFormValueWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(StringFormValueWrap)

//
// IFormValue properties
//

STDMETHODIMP StringFormValueWrap::COMGETTER(Type)(FormValueType_T *aType)
{
    LogRelFlow(("{%p} %s: enter aType=%p\n", this, "StringFormValue::getType", aType));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aType);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getType(aType);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 0 /*normal*/,*aType);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 1 /*hrc exception*/,*aType);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_TYPE_RETURN(this, hrc, 9 /*unhandled exception*/,*aType);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aType=%RU32 hrc=%Rhrc\n", this, "StringFormValue::getType", *aType, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Generation)(LONG *aGeneration)
{
    LogRelFlow(("{%p} %s: enter aGeneration=%p\n", this, "StringFormValue::getGeneration", aGeneration));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aGeneration);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getGeneration(aGeneration);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 0 /*normal*/,*aGeneration);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 1 /*hrc exception*/,*aGeneration);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_GENERATION_RETURN(this, hrc, 9 /*unhandled exception*/,*aGeneration);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aGeneration=%RI32 hrc=%Rhrc\n", this, "StringFormValue::getGeneration", *aGeneration, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Enabled)(BOOL *aEnabled)
{
    LogRelFlow(("{%p} %s: enter aEnabled=%p\n", this, "StringFormValue::getEnabled", aEnabled));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aEnabled);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getEnabled(aEnabled);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 0 /*normal*/,*aEnabled != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 1 /*hrc exception*/,*aEnabled != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_ENABLED_RETURN(this, hrc, 9 /*unhandled exception*/,*aEnabled != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aEnabled=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getEnabled", *aEnabled, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Visible)(BOOL *aVisible)
{
    LogRelFlow(("{%p} %s: enter aVisible=%p\n", this, "StringFormValue::getVisible", aVisible));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aVisible);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getVisible(aVisible);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 0 /*normal*/,*aVisible != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 1 /*hrc exception*/,*aVisible != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_VISIBLE_RETURN(this, hrc, 9 /*unhandled exception*/,*aVisible != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aVisible=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getVisible", *aVisible, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Label)(BSTR *aLabel)
{
    LogRelFlow(("{%p} %s: enter aLabel=%p\n", this, "StringFormValue::getLabel", aLabel));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aLabel);
        BSTROutConverter TmpLabel(aLabel);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getLabel(TmpLabel.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 0 /*normal*/,TmpLabel.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_LABEL_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aLabel=%ls hrc=%Rhrc\n", this, "StringFormValue::getLabel", *aLabel, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Description)(BSTR *aDescription)
{
    LogRelFlow(("{%p} %s: enter aDescription=%p\n", this, "StringFormValue::getDescription", aDescription));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aDescription);
        BSTROutConverter TmpDescription(aDescription);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getDescription(TmpDescription.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 0 /*normal*/,TmpDescription.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_DESCRIPTION_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aDescription=%ls hrc=%Rhrc\n", this, "StringFormValue::getDescription", *aDescription, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(Help)(BSTR *aHelp)
{
    LogRelFlow(("{%p} %s: enter aHelp=%p\n", this, "StringFormValue::getHelp", aHelp));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aHelp);
        BSTROutConverter TmpHelp(aHelp);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getHelp(TmpHelp.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 0 /*normal*/,TmpHelp.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_HELP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aHelp=%ls hrc=%Rhrc\n", this, "StringFormValue::getHelp", *aHelp, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute1IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute2IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute3IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute4IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute5IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute6IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute7IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute8IFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

//
// IStringFormValue properties
//

STDMETHODIMP StringFormValueWrap::COMGETTER(Multiline)(BOOL *aMultiline)
{
    LogRelFlow(("{%p} %s: enter aMultiline=%p\n", this, "StringFormValue::getMultiline", aMultiline));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMultiline);
        
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMultiline(aMultiline);
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 0 /*normal*/,*aMultiline != FALSE);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 1 /*hrc exception*/,*aMultiline != FALSE);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GET_MULTILINE_RETURN(this, hrc, 9 /*unhandled exception*/,*aMultiline != FALSE);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMultiline=%RTbool hrc=%Rhrc\n", this, "StringFormValue::getMultiline", *aMultiline, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute1IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute2IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute3IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::COMGETTER(InternalAndReservedAttribute4IStringFormValue)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IFormValue methods
//

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod1IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod2IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod3IFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod4IFormValue()
{
    return E_NOTIMPL;
}

//
// IStringFormValue methods
//

STDMETHODIMP StringFormValueWrap::GetString(BSTR *aText)
{
    LogRelFlow(("{%p} %s:enter aText=%p\n", this, "StringFormValue::getString", aText));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aText);


        BSTROutConverter TmpText(aText);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getString(TmpText.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 0 /*normal*/, TmpText.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 1 /*hrc exception*/, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_GETSTRING_RETURN(this, hrc, 9 /*unhandled exception*/, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aText=%ls hrc=%Rhrc\n", this, "StringFormValue::getString", *aText, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::SetString(IN_BSTR aText,
                                            IProgress **aProgress)
{
    LogRelFlow(("{%p} %s:enter aText=%ls aProgress=%p\n", this, "StringFormValue::setString", aText, aProgress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aProgress);


        BSTRInConverter TmpText(aText);
        ComTypeOutConverter<IProgress> TmpProgress(aProgress);

#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_ENTER(this, TmpText.str().c_str());
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = setString(TmpText.str(),
                            TmpProgress.ptr());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 0 /*normal*/, TmpText.str().c_str(), (void *)TmpProgress.ptr());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 1 /*hrc exception*/, 0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_STRINGFORMVALUE_SETSTRING_RETURN(this, hrc, 9 /*unhandled exception*/, 0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave aProgress=%p hrc=%Rhrc\n", this, "StringFormValue::setString", *aProgress, hrc));
    return hrc;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod1IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod2IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod3IStringFormValue()
{
    return E_NOTIMPL;
}

STDMETHODIMP StringFormValueWrap::InternalAndReservedMethod4IStringFormValue()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(StringFormValueWrap)
NS_IMPL_THREADSAFE_ISUPPORTS2_CI(StringFormValueWrap, IStringFormValue, IFormValue)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "StringFormValueWrap.cpp"


// ##### BEGINFILE "FormWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for IForm.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_FORM

#include "FormWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(FormWrap)

//
// IForm properties
//

STDMETHODIMP FormWrap::COMGETTER(Values)(ComSafeArrayOut(IFormValue *, aValues))
{
    LogRelFlow(("{%p} %s: enter aValues=%p\n", this, "Form::getValues", aValues));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aValues);
        ArrayComTypeOutConverter<IFormValue> TmpValues(ComSafeArrayOutArg(aValues));
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getValues(TmpValues.array());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 0 /*normal*/,(uint32_t)TmpValues.array().size(), NULL /*for now*/);
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 1 /*hrc exception*/,0, 0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_FORM_GET_VALUES_RETURN(this, hrc, 9 /*unhandled exception*/,0, 0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aValues=%zu hrc=%Rhrc\n", this, "Form::getValues", ComSafeArraySize(*aValues), hrc));
    return hrc;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute1IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute2IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute3IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::COMGETTER(InternalAndReservedAttribute4IForm)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// IForm methods
//

STDMETHODIMP FormWrap::InternalAndReservedMethod1IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod2IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod3IForm()
{
    return E_NOTIMPL;
}

STDMETHODIMP FormWrap::InternalAndReservedMethod4IForm()
{
    return E_NOTIMPL;
}

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(FormWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FormWrap, IForm)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "FormWrap.cpp"


// ##### BEGINFILE "CloudNetworkGatewayInfoWrap.cpp"
/** @file
 * VirtualBox API class wrapper code for ICloudNetworkGatewayInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#define LOG_GROUP LOG_GROUP_MAIN_CLOUDNETWORKGATEWAYINFO

#include "CloudNetworkGatewayInfoWrap.h"
#include "LoggingNew.h"
#ifdef VBOX_WITH_DTRACE_R3_MAIN
# include "dtrace/VBoxAPI.h"
#endif

DEFINE_EMPTY_CTOR_DTOR(CloudNetworkGatewayInfoWrap)

//
// ICloudNetworkGatewayInfo properties
//

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(PublicIP)(BSTR *aPublicIP)
{
    LogRelFlow(("{%p} %s: enter aPublicIP=%p\n", this, "CloudNetworkGatewayInfo::getPublicIP", aPublicIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aPublicIP);
        BSTROutConverter TmpPublicIP(aPublicIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getPublicIP(TmpPublicIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 0 /*normal*/,TmpPublicIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_PUBLICIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aPublicIP=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getPublicIP", *aPublicIP, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(SecondaryPublicIP)(BSTR *aSecondaryPublicIP)
{
    LogRelFlow(("{%p} %s: enter aSecondaryPublicIP=%p\n", this, "CloudNetworkGatewayInfo::getSecondaryPublicIP", aSecondaryPublicIP));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aSecondaryPublicIP);
        BSTROutConverter TmpSecondaryPublicIP(aSecondaryPublicIP);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getSecondaryPublicIP(TmpSecondaryPublicIP.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 0 /*normal*/,TmpSecondaryPublicIP.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_SECONDARYPUBLICIP_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aSecondaryPublicIP=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getSecondaryPublicIP", *aSecondaryPublicIP, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(MacAddress)(BSTR *aMacAddress)
{
    LogRelFlow(("{%p} %s: enter aMacAddress=%p\n", this, "CloudNetworkGatewayInfo::getMacAddress", aMacAddress));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aMacAddress);
        BSTROutConverter TmpMacAddress(aMacAddress);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getMacAddress(TmpMacAddress.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 0 /*normal*/,TmpMacAddress.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_MACADDRESS_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aMacAddress=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getMacAddress", *aMacAddress, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InstanceId)(BSTR *aInstanceId)
{
    LogRelFlow(("{%p} %s: enter aInstanceId=%p\n", this, "CloudNetworkGatewayInfo::getInstanceId", aInstanceId));

    // Clear error info, to make in-process calls behave the same as
    // cross-apartment calls or out-of-process calls.
    VirtualBoxBase::clearError();

    HRESULT hrc;

    try
    {
        CheckComArgOutPointerValidThrow(aInstanceId);
        BSTROutConverter TmpInstanceId(aInstanceId);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_ENTER(this);
#endif
        AutoCaller autoCaller(this);
        hrc = autoCaller.rc();
        if (SUCCEEDED(hrc))
        {
            hrc = getInstanceId(TmpInstanceId.str());
        }
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 0 /*normal*/,TmpInstanceId.str().c_str());
#endif
    }
    catch (HRESULT hrc2)
    {
        hrc = hrc2;
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 1 /*hrc exception*/,0);
#endif
    }
    catch (...)
    {
        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
#ifdef VBOX_WITH_DTRACE_R3_MAIN
        VBOXAPI_CLOUDNETWORKGATEWAYINFO_GET_INSTANCEID_RETURN(this, hrc, 9 /*unhandled exception*/,0);
#endif
    }

    LogRelFlow(("{%p} %s: leave *aInstanceId=%ls hrc=%Rhrc\n", this, "CloudNetworkGatewayInfo::getInstanceId", *aInstanceId, hrc));
    return hrc;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute1ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute2ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute3ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute4ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}

STDMETHODIMP CloudNetworkGatewayInfoWrap::COMGETTER(InternalAndReservedAttribute5ICloudNetworkGatewayInfo)(ULONG *aReserved)
{
    NOREF(aReserved);
    return E_NOTIMPL;
}


//
// ICloudNetworkGatewayInfo methods
//

#ifdef VBOX_WITH_XPCOM
NS_DECL_CLASSINFO(CloudNetworkGatewayInfoWrap)
NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CloudNetworkGatewayInfoWrap, ICloudNetworkGatewayInfo)
#endif // VBOX_WITH_XPCOM

// ##### ENDFILE "CloudNetworkGatewayInfoWrap.cpp"


// ##### BEGINFILE "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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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(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.rc();
        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", *aForm, *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.rc();
        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.rc();
        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", *aForm, *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.rc();
        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", *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.rc();
        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", *aForm, *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.rc();
        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::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.rc();
        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", *aReturnNames, *aReturnIds, *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.rc();
        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", *aReturnNames, *aReturnIds, *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *aInfoArray, *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.rc();
        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", *aGatewayInfo, *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.rc();
        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", *aNetworkEnvironmentInfo, *aProgress, 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;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod14ICloudClient()
{
    return E_NOTIMPL;
}

STDMETHODIMP CloudClientWrap::InternalAndReservedMethod15ICloudClient()
{
    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-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#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.rc();
        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", *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.rc();
        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", *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.rc();
        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", *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.rc();
        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", 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.rc();
        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", 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.rc();
        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", 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.rc();
        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", *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.rc();
        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.rc();
        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.rc();
        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.rc();
        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.rc();
        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", *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.rc();
        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"
