自学教程：C++ AssertPtrReturnVoid函数代码示例

/** * Releases the kernel module and closes its CTF data. * * @param pMod          Pointer to the module handle. * @param pCTF          Pointer to the module's CTF handle. */static void rtR0DbgKrnlInfoModRelease(modctl_t *pMod, ctf_file_t *pCTF){    AssertPtrReturnVoid(pMod);    AssertPtrReturnVoid(pCTF);    ctf_close(pCTF);}

/** * Get the information needed to map the area used by the host to send back * requests. * * @param  pCtx                the context containing the heap to use * @param  cbVRAM              how much video RAM is allocated to the device * @param  offVRAMBaseMapping  the offset of the basic communication structures *                             into the guest's VRAM * @param  poffVRAMHostArea    where to store the offset into VRAM of the host *                             heap area * @param  pcbHostArea         where to store the size of the host heap area */RTDECL(void) VBoxHGSMIGetHostAreaMapping(PHGSMIGUESTCOMMANDCONTEXT pCtx,                                         uint32_t cbVRAM,                                         uint32_t offVRAMBaseMapping,                                         uint32_t *poffVRAMHostArea,                                         uint32_t *pcbHostArea){    uint32_t offVRAMHostArea = offVRAMBaseMapping, cbHostArea = 0;    AssertPtrReturnVoid(poffVRAMHostArea);    AssertPtrReturnVoid(pcbHostArea);    VBoxQueryConfHGSMI(pCtx, VBOX_VBVA_CONF32_HOST_HEAP_SIZE, &cbHostArea);    if (cbHostArea != 0)    {        uint32_t cbHostAreaMaxSize = cbVRAM / 4;        /** @todo what is the idea of this? */        if (cbHostAreaMaxSize >= VBVA_ADAPTER_INFORMATION_SIZE)        {            cbHostAreaMaxSize -= VBVA_ADAPTER_INFORMATION_SIZE;        }        if (cbHostArea > cbHostAreaMaxSize)        {            cbHostArea = cbHostAreaMaxSize;        }        /* Round up to 4096 bytes. */        cbHostArea = (cbHostArea + 0xFFF) & ~0xFFF;        offVRAMHostArea = offVRAMBaseMapping - cbHostArea;    }    *pcbHostArea = cbHostArea;    *poffVRAMHostArea = offVRAMHostArea;    LogFunc(("offVRAMHostArea = 0x%08X, cbHostArea = 0x%08X/n",             offVRAMHostArea, cbHostArea));}

void UISettingsSerializerProgress::sltHandleOperationProgressChange(ulong iOperations, QString strOperation,                                                                    ulong iOperation, ulong iPercent){    /* Update the sub-operation progress label and bar: */    AssertPtrReturnVoid(m_pLabelSubOperationProgress);    AssertPtrReturnVoid(m_pBarSubOperationProgress);    m_pLabelSubOperationProgress->show();    m_pBarSubOperationProgress->show();    m_pLabelSubOperationProgress->setText(s_strProgressDescriptionTemplate.arg(strOperation).arg(iOperation).arg(iOperations));    m_pBarSubOperationProgress->setValue(iPercent);}

DECLINLINE(void) tftpProcessRRQ(PNATState pData, PCTFTPIPHDR pTftpIpHeader, int pktlen){    PTFTPSESSION pTftpSession = NULL;    uint8_t *pu8Payload = NULL;    int     cbPayload = 0;    size_t cbFileName = 0;    int rc = VINF_SUCCESS;    AssertPtrReturnVoid(pTftpIpHeader);    AssertPtrReturnVoid(pData);    AssertReturnVoid(pktlen > sizeof(TFTPIPHDR));    LogFlowFunc(("ENTER: pTftpIpHeader:%p, pktlen:%d/n", pTftpIpHeader, pktlen));    rc = tftpAllocateSession(pData, pTftpIpHeader, &pTftpSession);    if (   RT_FAILURE(rc)        || pTftpSession == NULL)    {        LogFlowFuncLeave();        return;    }    pu8Payload = (uint8_t *)&pTftpIpHeader->Core;    cbPayload = pktlen - sizeof(TFTPIPHDR);    cbFileName = RTStrNLen((char *)pu8Payload, cbPayload);    /* We assume that file name should finish with '/0' and shouldn't bigger     *  than buffer for name storage.     */    AssertReturnVoid(   cbFileName < cbPayload                     && cbFileName < TFTP_FILENAME_MAX /* current limit in tftp session handle */                     && cbFileName);    /* Dont't bother with rest processing in case of invalid access */    if (RT_FAILURE(tftpSecurityFilenameCheck(pData, pTftpSession)))    {        tftpSendError(pData, pTftpSession, 2, "Access violation", pTftpIpHeader);        LogFlowFuncLeave();        return;    }    if (RT_UNLIKELY(!tftpIsSupportedTransferMode(pTftpSession)))    {        tftpSendError(pData, pTftpSession, 4, "Unsupported transfer mode", pTftpIpHeader);        LogFlowFuncLeave();        return;    }    tftpSendOACK(pData, pTftpSession, pTftpIpHeader);    LogFlowFuncLeave();    return;}

/* static */void UIDnDEnumFormatEtc::CopyFormat(FORMATETC *pDest, FORMATETC *pSource){    AssertPtrReturnVoid(pDest);    AssertPtrReturnVoid(pSource);    *pDest = *pSource;    if (pSource->ptd)    {        pDest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));        *(pDest->ptd) = *(pSource->ptd);    }}

static void drvHostPulseAudioCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext){    AssertPtrReturnVoid(pStream);    PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;    AssertPtrReturnVoid(pStrm);    pStrm->fOpSuccess = fSuccess;    if (fSuccess)        drvHostPulseAudioAbortMainLoop();    else        drvHostPulseAudioError(pStrm->pDrv, "Failed to finish stream operation");}

void UIMachineSettingsGeneral::putToCache(){    /* Prepare general data: */    UIDataSettingsMachineGeneral generalData = m_cache.base();    /* 'Basic' tab data: */    AssertPtrReturnVoid(m_pNameAndSystemEditor);    generalData.m_strName = m_pNameAndSystemEditor->name();    generalData.m_strGuestOsTypeId = m_pNameAndSystemEditor->type().GetId();    /* 'Advanced' tab data: */    AssertPtrReturnVoid(mPsSnapshot);    AssertPtrReturnVoid(mCbClipboard);    AssertPtrReturnVoid(mCbDragAndDrop);    generalData.m_strSnapshotsFolder = mPsSnapshot->path();    generalData.m_clipboardMode = (KClipboardMode)mCbClipboard->currentIndex();    generalData.m_dndMode = (KDnDMode)mCbDragAndDrop->currentIndex();    /* 'Description' tab data: */    AssertPtrReturnVoid(mTeDescription);    generalData.m_strDescription = mTeDescription->toPlainText().isEmpty() ?                                   QString::null : mTeDescription->toPlainText();    /* 'Encryption' tab data: */    AssertPtrReturnVoid(m_pCheckBoxEncryption);    AssertPtrReturnVoid(m_pComboCipher);    AssertPtrReturnVoid(m_pEditorEncryptionPassword);    generalData.m_fEncryptionEnabled = m_pCheckBoxEncryption->isChecked();    generalData.m_fEncryptionCipherChanged = m_fEncryptionCipherChanged;    generalData.m_fEncryptionPasswordChanged = m_fEncryptionPasswordChanged;    generalData.m_iEncryptionCipherIndex = m_pComboCipher->currentIndex();    generalData.m_strEncryptionPassword = m_pEditorEncryptionPassword->text();    /* If encryption status, cipher or password is changed: */    if (generalData.m_fEncryptionEnabled != m_cache.base().m_fEncryptionEnabled ||        generalData.m_fEncryptionCipherChanged != m_cache.base().m_fEncryptionCipherChanged ||        generalData.m_fEncryptionPasswordChanged != m_cache.base().m_fEncryptionPasswordChanged)    {        /* Ask for the disk encryption passwords if necessary: */        if (!m_cache.base().m_encryptedMediums.isEmpty())        {            /* Create corresponding dialog: */            QWidget *pDlgParent = windowManager().realParentWindow(window());            QPointer<UIAddDiskEncryptionPasswordDialog> pDlg =                 new UIAddDiskEncryptionPasswordDialog(pDlgParent,                                                       generalData.m_strName,                                                       generalData.m_encryptedMediums);            /* Execute it and acquire the result: */            if (pDlg->exec() == QDialog::Accepted)                generalData.m_encryptionPasswords = pDlg->encryptionPasswords();            /* Delete dialog if still valid: */            if (pDlg)                delete pDlg;        }    }    /* Cache general data: */    m_cache.cacheCurrentData(generalData);}

void UIHostNetworkManagerWidget::prepareTreeWidget(){    /* Create tree-widget: */    m_pTreeWidget = new QITreeWidget;    AssertPtrReturnVoid(m_pTreeWidget);    {        /* Configure tree-widget: */        m_pTreeWidget->setRootIsDecorated(false);        m_pTreeWidget->setAlternatingRowColors(true);        m_pTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);        m_pTreeWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);        m_pTreeWidget->setColumnCount(Column_Max);        m_pTreeWidget->setSortingEnabled(true);        m_pTreeWidget->sortByColumn(Column_Name, Qt::AscendingOrder);        m_pTreeWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);        connect(m_pTreeWidget, &QITreeWidget::currentItemChanged,                this, &UIHostNetworkManagerWidget::sltHandleCurrentItemChange);        connect(m_pTreeWidget, &QITreeWidget::customContextMenuRequested,                this, &UIHostNetworkManagerWidget::sltHandleContextMenuRequest);        connect(m_pTreeWidget, &QITreeWidget::itemChanged,                this, &UIHostNetworkManagerWidget::sltHandleItemChange);        connect(m_pTreeWidget, &QITreeWidget::itemDoubleClicked,                m_pActionPool->action(UIActionIndexST_M_Network_T_Details), &QAction::setChecked);        /* Add into layout: */        layout()->addWidget(m_pTreeWidget);    }}

void UIMachineWindowFullscreen::adjustMachineViewSize(){    /* Call to base-class: */    UIMachineWindow::adjustMachineViewSize();#ifndef Q_WS_MAC    /* If mini-toolbar present: */    if (m_pMiniToolBar)    {        /* Make sure this window has fullscreen logic: */        const UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());        AssertPtrReturnVoid(pFullscreenLogic);        /* Which host-screen should that machine-window located on? */        const int iHostScreen = pFullscreenLogic->hostScreenForGuestScreen(m_uScreenId);#ifndef Q_WS_X11        /* Move mini-toolbar into appropriate place: */        m_pMiniToolBar->adjustGeometry(iHostScreen);#else /* Q_WS_X11 */        /* On modern WMs we are mapping mini-toolbar to corresponding host-screen directly. */        const bool fSupportsNativeFullScreen = VBoxGlobal::supportsFullScreenMonitorsProtocolX11() &&                                               !gEDataManager->legacyFullscreenModeRequested();        /* Adjust mini-toolbar and move into appropriate place if necessary: */        m_pMiniToolBar->adjustGeometry(fSupportsNativeFullScreen ? -1 : iHostScreen);#endif /* Q_WS_X11 */    }#endif /* !Q_WS_MAC */}

void UIActionPool::updateMenuHelp(){    /* Get corresponding menu: */    UIMenu *pMenu = action(UIActionIndex_Menu_Help)->menu();    AssertPtrReturnVoid(pMenu);    /* Clear contents: */    pMenu->clear();    /* Separator? */    bool fSeparator = false;    /* 'Contents' action: */    fSeparator = addAction(pMenu, action(UIActionIndex_Simple_Contents)) || fSeparator;;    /* 'Web Site' action: */    fSeparator = addAction(pMenu, action(UIActionIndex_Simple_WebSite)) || fSeparator;;    /* Separator? */    if (fSeparator)    {        pMenu->addSeparator();        fSeparator = false;    }#ifndef RT_OS_DARWIN    /* 'About' action: */    fSeparator = addAction(pMenu, action(UIActionIndex_Simple_About)) || fSeparator;;#endif /* !RT_OS_DARWIN */    /* Mark menu as valid: */    m_invalidations.remove(UIActionIndex_Menu_Help);}

void UIHostNetworkManagerWidget::prepareToolBar(){    /* Create toolbar: */    m_pToolBar = new UIToolBar(parentWidget());    AssertPtrReturnVoid(m_pToolBar);    {        /* Configure toolbar: */        const int iIconMetric = (int)(QApplication::style()->pixelMetric(QStyle::PM_LargeIconSize));        m_pToolBar->setIconSize(QSize(iIconMetric, iIconMetric));        m_pToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);        /* Add toolbar actions: */        m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Create));        m_pToolBar->addSeparator();        m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Remove));        m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_T_Details));//        m_pToolBar->addSeparator();//        m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Refresh));#ifdef VBOX_WS_MAC        /* Check whether we are embedded into a stack: */        if (m_enmEmbedding == EmbedTo_Stack)        {            /* Add into layout: */            layout()->addWidget(m_pToolBar);        }#else        /* Add into layout: */        layout()->addWidget(m_pToolBar);#endif    }}

void UIPopupCenter::setPopupStackOrientation(QWidget *pParent, UIPopupStackOrientation newStackOrientation){    /* Make sure parent is set! */    AssertPtrReturnVoid(pParent);    /* Composing corresponding popup-stack ID: */    const QString strPopupStackID(popupStackID(pParent));    /* Looking for current popup-stack orientation, create if it doesn't exists: */    UIPopupStackOrientation &stackOrientation = m_stackOrientations[strPopupStackID];    /* Make sure stack-orientation has changed: */    if (stackOrientation == newStackOrientation)        return;    /* Remember new stack orientation: */    LogRelFlow(("UIPopupCenter::setPopupStackType: Changing orientation of popup-stack with ID = '%s' from '%s' to '%s'./n",                strPopupStackID.toAscii().constData(),                stackOrientation == UIPopupStackOrientation_Top ? "top oriented" : "bottom oriented",                newStackOrientation == UIPopupStackOrientation_Top ? "top oriented" : "bottom oriented"));    stackOrientation = newStackOrientation;    /* Update orientation for popup-stack if it currently exists: */    if (m_stacks.contains(strPopupStackID))        m_stacks[strPopupStackID]->setOrientation(stackOrientation);}

static void drvHostPulseAudioCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext){    AssertPtrReturnVoid(pStream);    PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;    AssertPtrReturnVoid(pStrm);    pStrm->fOpSuccess = fSuccess;    if (fSuccess)    {        pa_threaded_mainloop_signal(g_pMainLoop, 0 /* fWait */);    }    else         drvHostPulseAudioError(pStrm->pDrv, "Failed to finish stream operation");}

void VBoxAboutDlg::prepareCloseButton(){    /* Create button-box: */    QDialogButtonBox *pButtonBox = new QDialogButtonBox;    AssertPtrReturnVoid(pButtonBox);    {        /* Create close-button: */        QPushButton *pCloseButton = pButtonBox->addButton(QDialogButtonBox::Close);        AssertPtrReturnVoid(pCloseButton);        /* Prepare close-button: */        connect(pButtonBox, SIGNAL(rejected()), this, SLOT(reject()));        /* Add button-box to the main-layout: */        m_pMainLayout->addWidget(pButtonBox);    }}

UIInformationItem::UIInformationItem(QObject *pParent)    : QStyledItemDelegate(pParent){    /* Create text-document: */    m_pTextDocument = new QTextDocument(this);    AssertPtrReturnVoid(m_pTextDocument);}

void UIVMInformationDialog::prepareTabWidget(){    /* Create tab-widget: */    m_pTabWidget = new QITabWidget;    AssertPtrReturnVoid(m_pTabWidget);    {        /* Create tabs: */        /* Create Configuration details tab: */        UIGInformation *pInformationWidget = new UIGInformation(this);        QList<UIVMItem*> items;        items << new UIVMItem(gpMachine->uisession()->machine());        pInformationWidget->setItems(items);        m_tabs.insert(0, pInformationWidget);        m_pTabWidget->addTab(m_tabs.value(0), QString());        for (int iTabIndex = 1; iTabIndex < 2; ++iTabIndex)            prepareTab(iTabIndex);        /* Configure tab-widget: */        m_pTabWidget->setTabIcon(0, UIIconPool::iconSet(":/session_info_details_16px.png"));        m_pTabWidget->setTabIcon(1, UIIconPool::iconSet(":/session_info_runtime_16px.png"));        m_pTabWidget->setCurrentIndex(1);        /* Add tab-widget into main-layout: */        centralWidget()->layout()->addWidget(m_pTabWidget);    }}

void UIInformationModel::addItem(UIInformationDataItem *pItem){    /* Make sure item is valid: */    AssertPtrReturnVoid(pItem);    /* Add item: */    m_list.append(pItem);}

void UIMachineWindowFullscreen::prepareMiniToolbar(){    /* Make sure mini-toolbar is not restricted: */    if (!gEDataManager->miniToolbarEnabled(vboxGlobal().managedVMUuid()))        return;    /* Create mini-toolbar: */    m_pMiniToolBar = new UIMiniToolBar(this,                                       GeometryType_Full,                                       gEDataManager->miniToolbarAlignment(vboxGlobal().managedVMUuid()),                                       gEDataManager->autoHideMiniToolbar(vboxGlobal().managedVMUuid()));    AssertPtrReturnVoid(m_pMiniToolBar);    {        /* Configure mini-toolbar: */        m_pMiniToolBar->addMenus(actionPool()->menus());        connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()),                this, SLOT(showMinimized()), Qt::QueuedConnection);        connect(m_pMiniToolBar, SIGNAL(sigExitAction()),                actionPool()->action(UIActionIndexRT_M_View_T_Fullscreen), SLOT(trigger()));        connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),                actionPool()->action(UIActionIndex_M_Application_S_Close), SLOT(trigger()));        connect(m_pMiniToolBar, SIGNAL(sigNotifyAboutWindowActivationStolen()),                this, SLOT(sltRevokeWindowActivation()), Qt::QueuedConnection);# ifdef Q_WS_X11        // WORKAROUND:        // Due to Unity bug we want native full-screen flag to be set        // for mini-toolbar _before_ trying to show it in full-screen mode.        // That significantly improves of chances to have required geometry.        if (vboxGlobal().typeOfWindowManager() == X11WMType_Compiz)            vboxGlobal().setFullScreenFlag(m_pMiniToolBar);# endif /* Q_WS_X11 */    }}

void UIMachineWindowFullscreen::sltEnterNativeFullscreen(UIMachineWindow *pMachineWindow){    /* Make sure this slot is called only under ML and next: */    AssertReturnVoid(vboxGlobal().osRelease() > MacOSXRelease_Lion);    /* Make sure it is NULL or 'this' window passed: */    if (pMachineWindow && pMachineWindow != this)        return;    /* Make sure this window has fullscreen logic: */    UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());    AssertPtrReturnVoid(pFullscreenLogic);    /* Make sure this window should be shown and mapped to host-screen: */    if (!uisession()->isScreenVisible(m_uScreenId) ||        !pFullscreenLogic->hasHostScreenForGuestScreen(m_uScreenId))        return;    /* Mark window 'transitioned to fullscreen': */    m_fIsInFullscreenTransition = true;    /* Enter native fullscreen mode if necessary: */    if (   (pFullscreenLogic->screensHaveSeparateSpaces() || m_uScreenId == 0)        && !darwinIsInFullscreenMode(this))        darwinToggleFullscreenMode(this);}

/* static */void VBoxDnDDropTarget::DumpFormats(IDataObject *pDataObject){    AssertPtrReturnVoid(pDataObject);    /* Enumerate supported source formats. This shouldn't happen too often     * on day to day use, but still keep it in here. */    IEnumFORMATETC *pEnumFormats;    HRESULT hr2 = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormats);    if (SUCCEEDED(hr2))    {        LogRel(("DnD: The following formats were offered to us:/n"));        FORMATETC curFormatEtc;        while (pEnumFormats->Next(1, &curFormatEtc,                                  NULL /* pceltFetched */) == S_OK)        {            WCHAR wszCfName[128]; /* 128 chars should be enough, rest will be truncated. */            hr2 = GetClipboardFormatNameW(curFormatEtc.cfFormat, wszCfName,                                          sizeof(wszCfName) / sizeof(WCHAR));            LogRel(("/tcfFormat=%RI16 (%s), tyMed=%RI32, dwAspect=%RI32, strCustomName=%ls, hr=%Rhrc/n",                    curFormatEtc.cfFormat,                    VBoxDnDDataObject::ClipboardFormatToString(curFormatEtc.cfFormat),                    curFormatEtc.tymed,                    curFormatEtc.dwAspect,                    wszCfName, hr2));        }        pEnumFormats->Release();    }}

void UIMachineWindowFullscreen::prepareMiniToolbar(){    /* Make sure mini-toolbar is not restricted: */    if (!gEDataManager->miniToolbarEnabled(vboxGlobal().managedVMUuid()))        return;    /* Create mini-toolbar: */    m_pMiniToolBar = new UIMiniToolBar(this,                                       GeometryType_Full,                                       gEDataManager->miniToolbarAlignment(vboxGlobal().managedVMUuid()),                                       gEDataManager->autoHideMiniToolbar(vboxGlobal().managedVMUuid()));    AssertPtrReturnVoid(m_pMiniToolBar);    {        /* Configure mini-toolbar: */        m_pMiniToolBar->addMenus(actionPool()->menus());        connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()),                this, SLOT(showMinimized()), Qt::QueuedConnection);        connect(m_pMiniToolBar, SIGNAL(sigExitAction()),                actionPool()->action(UIActionIndexRT_M_View_T_Fullscreen), SLOT(trigger()));        connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),                actionPool()->action(UIActionIndex_M_Application_S_Close), SLOT(trigger()));        connect(m_pMiniToolBar, SIGNAL(sigNotifyAboutWindowActivationStolen()),                this, SLOT(sltRevokeWindowActivation()), Qt::QueuedConnection);    }}

void UIMachineLogicNormal::sltOpenStatusBarSettings(){    /* Do not process if window(s) missed! */    AssertReturnVoid(isMachineWindowsCreated());    /* Make sure status-bar is enabled: */    const bool fEnabled = actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->isChecked();    AssertReturnVoid(fEnabled);    /* Prevent user from opening another one editor or toggle status-bar: */    actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings)->setEnabled(false);    actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->setEnabled(false);    /* Create status-bar editor: */    UIStatusBarEditorWindow *pStatusBarEditor = new UIStatusBarEditorWindow(activeMachineWindow());    AssertPtrReturnVoid(pStatusBarEditor);    {        /* Configure status-bar editor: */        connect(pStatusBarEditor, SIGNAL(destroyed(QObject*)),                this, SLOT(sltStatusBarSettingsClosed()));#ifdef Q_WS_MAC        connect(this, SIGNAL(sigNotifyAbout3DOverlayVisibilityChange(bool)),                pStatusBarEditor, SLOT(sltActivateWindow()));#endif /* Q_WS_MAC */        /* Show window: */        pStatusBarEditor->show();    }}

void VDMemDiskDestroy(PVDMEMDISK pMemDisk){    AssertPtrReturnVoid(pMemDisk);    RTAvlrU64Destroy(pMemDisk->pTreeSegments, vdMemDiskDestroy, NULL);    RTMemFree(pMemDisk->pTreeSegments);    RTMemFree(pMemDisk);}

void UIVMInformationDialog::prepareCentralWidget(){    /* Create central-widget: */    setCentralWidget(new QWidget);    AssertPtrReturnVoid(centralWidget());    {        /* Create main-layout: */        new QVBoxLayout(centralWidget());        AssertPtrReturnVoid(centralWidget()->layout());        {            /* Create tab-widget: */            prepareTabWidget();            /* Create button-box: */            prepareButtonBox();        }    }}

void UINetworkRequest::cleanupNetworkReply(){    /* Destroy network-reply: */    AssertPtrReturnVoid(m_pReply.data());    m_pReply->disconnect();    m_pReply->deleteLater();    m_pReply = 0;}