VirtualBox

Changeset 25198 in vbox


Ignore:
Timestamp:
Dec 4, 2009 5:53:00 PM (15 years ago)
Author:
vboxsync
Message:

Main: make StorageController instance data private

Location:
trunk/src/VBox/Main
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/MachineImpl.cpp

    r25194 r25198  
    38303830         ++it)
    38313831    {
    3832         if ((*it)->storageBus() == aConnectionType)
    3833         {
    3834             ULONG ulCurInst = (*it)->instance();
     3832        if ((*it)->getStorageBus() == aConnectionType)
     3833        {
     3834            ULONG ulCurInst = (*it)->getInstance();
    38353835
    38363836            if (ulCurInst >= ulInstance)
    … …  
    38853885         ++it)
    38863886    {
    3887         if ((*it)->instance() == aInstance)
     3887        if ((*it)->getInstance() == aInstance)
    38883888        {
    38893889            (*it).queryInterfaceTo(aStorageController);
    … …  
    61946194                return setError(E_FAIL,
    61956195                                tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%ls'"),
    6196                                 aStorageController->name().raw(), (*it).lPort, (*it).lDevice, mUserData->mName.raw());
     6196                                aStorageController->getName().raw(), (*it).lPort, (*it).lDevice, mUserData->mName.raw());
    61976197            }
    61986198        }
    … …  
    63386338            break;
    63396339
    6340         const Bstr controllerName = aStorageController->name();
     6340        const Bstr controllerName = aStorageController->getName();
    63416341        ComObjPtr<MediumAttachment> pAttachment;
    63426342        pAttachment.createObject();
    … …  
    64616461         ++it)
    64626462    {
    6463         if ((*it)->name() == aName)
     6463        if ((*it)->getName() == aName)
    64646464        {
    64656465            aStorageController = (*it);
    … …  
    70957095
    70967096        settings::StorageController ctl;
    7097         ctl.strName = pCtl->name();
    7098         ctl.controllerType = pCtl->controllerType();
    7099         ctl.storageBus = pCtl->storageBus();
    7100         ctl.ulInstance = pCtl->instance();
     7097        ctl.strName = pCtl->getName();
     7098        ctl.controllerType = pCtl->getControllerType();
     7099        ctl.storageBus = pCtl->getStorageBus();
     7100        ctl.ulInstance = pCtl->getInstance();
    71017101
    71027102        /* Save the port count. */
    … …  
    71357135    MediaData::AttachmentList atts;
    71367136
    7137     HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->name()), atts);
     7137    HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()), atts);
    71387138    if (FAILED(rc)) return rc;
    71397139
    … …  
    81718171
    81728172                /* look if this controller has a peer device */
    8173                 ComObjPtr<StorageController> peer = (*it)->peer();
     8173                ComObjPtr<StorageController> peer = (*it)->getPeer();
    81748174                if (!peer)
    81758175                {

  • trunk/src/VBox/Main/StorageControllerImpl.cpp

    r25149 r25198  
    3838/////////////////////////////////////////////////////////////////////////////
    3939
     40struct BackupableStorageControllerData
     41{
     42    /* Constructor. */
     43    BackupableStorageControllerData()
     44        : mStorageBus(StorageBus_IDE),
     45          mStorageControllerType(StorageControllerType_PIIX4),
     46          mInstance(0),
     47          mPortCount(2),
     48          mPortIde0Master(0),
     49          mPortIde0Slave(1),
     50          mPortIde1Master(2),
     51          mPortIde1Slave(3)
     52    { }
     53
     54    bool operator==(const BackupableStorageControllerData &that) const
     55    {
     56        return    this == &that
     57                || (    (mStorageControllerType == that.mStorageControllerType)
     58                    && (strName           == that.strName)
     59                    && (mPortCount   == that.mPortCount)
     60                    && (mPortIde0Master == that.mPortIde0Master)
     61                    && (mPortIde0Slave  == that.mPortIde0Slave)
     62                    && (mPortIde1Master == that.mPortIde1Master)
     63                    && (mPortIde1Slave  == that.mPortIde1Slave));
     64    }
     65
     66    /** Unique name of the storage controller. */
     67    Utf8Str strName;
     68    /** The connection type of thestorage controller. */
     69    StorageBus_T mStorageBus;
     70    /** Type of the Storage controller. */
     71    StorageControllerType_T mStorageControllerType;
     72    /** Instance number of the storage controller. */
     73    ULONG mInstance;
     74    /** Number of usable ports. */
     75    ULONG mPortCount;
     76
     77    /** The following is only for the SATA controller atm. */
     78    /** Port which acts as primary master for ide emulation. */
     79    ULONG mPortIde0Master;
     80    /** Port which acts as primary slave for ide emulation. */
     81    ULONG mPortIde0Slave;
     82    /** Port which acts as secondary master for ide emulation. */
     83    ULONG mPortIde1Master;
     84    /** Port which acts as secondary slave for ide emulation. */
     85    ULONG mPortIde1Slave;
     86};
     87
     88struct StorageController::Data
     89{
     90    const ComObjPtr<Machine, ComWeakRef>    pParent;
     91    const ComObjPtr<StorageController>      pPeer;
     92
     93    Backupable<BackupableStorageControllerData> bd;
     94};
     95
    4096// constructor / destructor
    4197/////////////////////////////////////////////////////////////////////////////
    42 
    43 DEFINE_EMPTY_CTOR_DTOR (StorageController)
    4498
    4599HRESULT StorageController::FinalConstruct()
    … …  
    82136    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    83137
    84     unconst(mParent) = aParent;
    85     /* mPeer is left null */
     138    m = new Data();
     139
     140    unconst(m->pParent) = aParent;
     141    /* m->pPeer is left null */
    86142
    87143    /* register with parent early, since uninit() will unconditionally
    88144     * unregister on failure */
    89     mParent->addDependentChild (this);
    90 
    91     mData.allocate();
    92 
    93     mData->strName = aName;
    94     mData->mInstance = aInstance;
    95     mData->mStorageBus = aStorageBus;
     145    m->pParent->addDependentChild (this);
     146
     147    m->bd.allocate();
     148
     149    m->bd->strName = aName;
     150    m->bd->mInstance = aInstance;
     151    m->bd->mStorageBus = aStorageBus;
    96152
    97153    switch (aStorageBus)
    98154    {
    99155        case StorageBus_IDE:
    100             mData->mPortCount = 2;
    101             mData->mStorageControllerType = StorageControllerType_PIIX4;
     156            m->bd->mPortCount = 2;
     157            m->bd->mStorageControllerType = StorageControllerType_PIIX4;
    102158            break;
    103159        case StorageBus_SATA:
    104             mData->mPortCount = 30;
    105             mData->mStorageControllerType = StorageControllerType_IntelAhci;
     160            m->bd->mPortCount = 30;
     161            m->bd->mStorageControllerType = StorageControllerType_IntelAhci;
    106162            break;
    107163        case StorageBus_SCSI:
    108             mData->mPortCount = 16;
    109             mData->mStorageControllerType = StorageControllerType_LsiLogic;
     164            m->bd->mPortCount = 16;
     165            m->bd->mStorageControllerType = StorageControllerType_LsiLogic;
    110166            break;
    111167        case StorageBus_Floppy:
    112168            /** @todo allow 2 floppies later */
    113             mData->mPortCount = 1;
    114             mData->mStorageControllerType = StorageControllerType_I82078;
     169            m->bd->mPortCount = 1;
     170            m->bd->mStorageControllerType = StorageControllerType_I82078;
    115171            break;
    116172    }
    … …  
    138194 *  reading if @a aReshare is false.
    139195 */
    140 HRESULT StorageController::init (Machine *aParent,
    141                                  StorageController *aThat,
    142                                  bool aReshare /* = false */)
     196HRESULT StorageController::init(Machine *aParent,
     197                                StorageController *aThat,
     198                                bool aReshare /* = false */)
    143199{
    144200    LogFlowThisFunc(("aParent=%p, aThat=%p, aReshare=%RTbool\n",
    … …  
    151207    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    152208
    153     unconst(mParent) = aParent;
     209    m = new Data();
     210
     211    unconst(m->pParent) = aParent;
    154212
    155213    /* register with parent early, since uninit() will unconditionally
    156214     * unregister on failure */
    157     mParent->addDependentChild (this);
     215    m->pParent->addDependentChild (this);
    158216
    159217    /* sanity */
    … …  
    165223        AutoWriteLock thatLock (aThat);
    166224
    167         unconst(aThat->mPeer) = this;
    168         mData.attach (aThat->mData);
     225        unconst(aThat->m->pPeer) = this;
     226        m->bd.attach (aThat->m->bd);
    169227    }
    170228    else
    171229    {
    172         unconst(mPeer) = aThat;
     230        unconst(m->pPeer) = aThat;
    173231
    174232        AutoReadLock thatLock (aThat);
    175         mData.share (aThat->mData);
     233        m->bd.share (aThat->m->bd);
    176234    }
    177235
    … …  
    187245 *  of the original object passed as an argument.
    188246 */
    189 HRESULT StorageController::initCopy (Machine *aParent, StorageController *aThat)
     247HRESULT StorageController::initCopy(Machine *aParent, StorageController *aThat)
    190248{
    191249    LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
    … …  
    197255    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    198256
    199     unconst(mParent) = aParent;
    200     /* mPeer is left null */
    201 
    202     mParent->addDependentChild (this);
     257    m = new Data();
     258
     259    unconst(m->pParent) = aParent;
     260    /* m->pPeer is left null */
     261
     262    m->pParent->addDependentChild (this);
    203263
    204264    AutoCaller thatCaller (aThat);
    … …  
    206266
    207267    AutoReadLock thatlock (aThat);
    208     mData.attachCopy (aThat->mData);
     268    m->bd.attachCopy (aThat->m->bd);
    209269
    210270    /* Confirm a successful initialization */
    … …  
    228288        return;
    229289
    230     mData.free();
    231 
    232     mParent->removeDependentChild (this);
    233 
    234     unconst(mPeer).setNull();
    235     unconst(mParent).setNull();
     290    m->bd.free();
     291
     292    m->pParent->removeDependentChild (this);
     293
     294    unconst(m->pPeer).setNull();
     295    unconst(m->pParent).setNull();
     296
     297    delete m;
     298    m = NULL;
    236299}
    237300
    … …  
    247310
    248311    /* mName is constant during life time, no need to lock */
    249     mData.data()->strName.cloneTo(aName);
     312    m->bd.data()->strName.cloneTo(aName);
    250313
    251314    return S_OK;
    … …  
    261324    AutoReadLock alock(this);
    262325
    263     *aBus = mData->mStorageBus;
     326    *aBus = m->bd->mStorageBus;
    264327
    265328    return S_OK;
    … …  
    275338    AutoReadLock alock(this);
    276339
    277     *aControllerType = mData->mStorageControllerType;
     340    *aControllerType = m->bd->mStorageControllerType;
    278341
    279342    return S_OK;
    … …  
    289352    HRESULT rc = S_OK;
    290353
    291     switch (mData->mStorageBus)
     354    switch (m->bd->mStorageBus)
    292355    {
    293356        case StorageBus_IDE:
    … …  
    319382        }
    320383        default:
    321             AssertMsgFailed(("Invalid controller type %d\n", mData->mStorageBus));
     384            AssertMsgFailed(("Invalid controller type %d\n", m->bd->mStorageBus));
    322385    }
    323386
    … …  
    327390                        aControllerType);
    328391
    329     mData->mStorageControllerType = aControllerType;
     392    m->bd->mStorageControllerType = aControllerType;
    330393
    331394    return S_OK;
    … …  
    342405
    343406    ComPtr<IVirtualBox> VBox;
    344     HRESULT rc = mParent->COMGETTER(Parent)(VBox.asOutParam());
     407    HRESULT rc = m->pParent->COMGETTER(Parent)(VBox.asOutParam());
    345408    if (FAILED(rc))
    346409        return rc;
    … …  
    351414        return rc;
    352415
    353     rc = sysProps->GetMaxDevicesPerPortForStorageBus(mData->mStorageBus, aMaxDevices);
     416    rc = sysProps->GetMaxDevicesPerPortForStorageBus(m->bd->mStorageBus, aMaxDevices);
    354417    return rc;
    355418}
    … …  
    365428
    366429    ComPtr<IVirtualBox> VBox;
    367     HRESULT rc = mParent->COMGETTER(Parent)(VBox.asOutParam());
     430    HRESULT rc = m->pParent->COMGETTER(Parent)(VBox.asOutParam());
    368431    if (FAILED(rc))
    369432        return rc;
    … …  
    374437        return rc;
    375438
    376     rc = sysProps->GetMinPortCountForStorageBus(mData->mStorageBus, aMinPortCount);
     439    rc = sysProps->GetMinPortCountForStorageBus(m->bd->mStorageBus, aMinPortCount);
    377440    return rc;
    378441}
    … …  
    388451
    389452    ComPtr<IVirtualBox> VBox;
    390     HRESULT rc = mParent->COMGETTER(Parent)(VBox.asOutParam());
     453    HRESULT rc = m->pParent->COMGETTER(Parent)(VBox.asOutParam());
    391454    if (FAILED(rc))
    392455        return rc;
    … …  
    397460        return rc;
    398461
    399     rc = sysProps->GetMaxPortCountForStorageBus(mData->mStorageBus, aMaxPortCount);
     462    rc = sysProps->GetMaxPortCountForStorageBus(m->bd->mStorageBus, aMaxPortCount);
    400463    return rc;
    401464}
    … …  
    411474    AutoReadLock alock(this);
    412475
    413     *aPortCount = mData->mPortCount;
     476    *aPortCount = m->bd->mPortCount;
    414477
    415478    return S_OK;
    … …  
    421484    LogFlowThisFunc(("aPortCount=%u\n", aPortCount));
    422485
    423     switch (mData->mStorageBus)
     486    switch (m->bd->mStorageBus)
    424487    {
    425488        case StorageBus_SATA:
    … …  
    470533        }
    471534        default:
    472             AssertMsgFailed(("Invalid controller type %d\n", mData->mStorageBus));
     535            AssertMsgFailed(("Invalid controller type %d\n", m->bd->mStorageBus));
    473536    }
    474537
    … …  
    477540
    478541    /* the machine needs to be mutable */
    479     Machine::AutoMutableStateDependency adep(mParent);
     542    Machine::AutoMutableStateDependency adep(m->pParent);
    480543    if (FAILED(adep.rc())) return adep.rc();
    481544
    482545    AutoWriteLock alock(this);
    483546
    484     if (mData->mPortCount != aPortCount)
    485     {
    486         mData.backup();
    487         mData->mPortCount = aPortCount;
     547    if (m->bd->mPortCount != aPortCount)
     548    {
     549        m->bd.backup();
     550        m->bd->mPortCount = aPortCount;
    488551
    489552        /* leave the lock for safety */
    490553        alock.leave();
    491554
    492         mParent->onStorageControllerChange ();
     555        m->pParent->onStorageControllerChange ();
    493556    }
    494557
    … …  
    505568    AutoReadLock alock(this);
    506569
    507     *aInstance = mData->mInstance;
     570    *aInstance = m->bd->mInstance;
    508571
    509572    return S_OK;
    … …  
    519582    AutoWriteLock alock(this);
    520583
    521     mData->mInstance = aInstance;
     584    m->bd->mInstance = aInstance;
    522585
    523586    return S_OK;
    … …  
    536599    AutoReadLock alock(this);
    537600
    538     if (mData->mStorageControllerType != StorageControllerType_IntelAhci)
     601    if (m->bd->mStorageControllerType != StorageControllerType_IntelAhci)
    539602        return setError (E_NOTIMPL,
    540603            tr ("Invalid controller type"));
    … …  
    543606    {
    544607        case 0:
    545             *aPortNumber = mData->mPortIde0Master;
     608            *aPortNumber = m->bd->mPortIde0Master;
    546609            break;
    547610        case 1:
    548             *aPortNumber = mData->mPortIde0Slave;
     611            *aPortNumber = m->bd->mPortIde0Slave;
    549612            break;
    550613        case 2:
    551             *aPortNumber = mData->mPortIde1Master;
     614            *aPortNumber = m->bd->mPortIde1Master;
    552615            break;
    553616        case 3:
    554             *aPortNumber = mData->mPortIde1Slave;
     617            *aPortNumber = m->bd->mPortIde1Slave;
    555618            break;
    556619        default:
    … …  
    567630
    568631    /* the machine needs to be mutable */
    569     Machine::AutoMutableStateDependency adep(mParent);
     632    Machine::AutoMutableStateDependency adep(m->pParent);
    570633    if (FAILED(adep.rc())) return adep.rc();
    571634    AutoWriteLock alock(this);
    572635
    573     if (mData->mStorageControllerType != StorageControllerType_IntelAhci)
     636    if (m->bd->mStorageControllerType != StorageControllerType_IntelAhci)
    574637        return setError (E_NOTIMPL,
    575638            tr ("Invalid controller type"));
    … …  
    583646    {
    584647        case 0:
    585             mData->mPortIde0Master = aPortNumber;
     648            m->bd->mPortIde0Master = aPortNumber;
    586649            break;
    587650        case 1:
    588             mData->mPortIde0Slave = aPortNumber;
     651            m->bd->mPortIde0Slave = aPortNumber;
    589652            break;
    590653        case 2:
    591             mData->mPortIde1Master = aPortNumber;
     654            m->bd->mPortIde1Master = aPortNumber;
    592655            break;
    593656        case 3:
    594             mData->mPortIde1Slave = aPortNumber;
     657            m->bd->mPortIde1Slave = aPortNumber;
    595658            break;
    596659        default:
    … …  
    604667/////////////////////////////////////////////////////////////////////////////
    605668
     669
     670const Utf8Str& StorageController::getName() const
     671{
     672    return m->bd->strName;
     673}
     674
     675StorageControllerType_T StorageController::getControllerType() const
     676{
     677    return m->bd->mStorageControllerType;
     678}
     679
     680StorageBus_T StorageController::getStorageBus() const
     681{
     682    return m->bd->mStorageBus;
     683}
     684
     685ULONG StorageController::getInstance() const
     686{
     687    return m->bd->mInstance;
     688}
     689
     690bool StorageController::isModified()
     691{
     692    AutoWriteLock alock(this);
     693    return m->bd.isBackedUp();
     694}
     695
     696bool StorageController::isReallyModified()
     697{
     698    AutoWriteLock alock(this);
     699    return m->bd.hasActualChanges();
     700}
     701
    606702/** @note Locks objects for writing! */
    607703bool StorageController::rollback()
    … …  
    614710    bool dataChanged = false;
    615711
    616     if (mData.isBackedUp())
     712    if (m->bd.isBackedUp())
    617713    {
    618714        /* we need to check all data to see whether anything will be changed
    619715         * after rollback */
    620         dataChanged = mData.hasActualChanges();
    621         mData.rollback();
     716        dataChanged = m->bd.hasActualChanges();
     717        m->bd.rollback();
    622718    }
    623719
    … …  
    636732
    637733    /* sanity too */
    638     AutoCaller peerCaller (mPeer);
     734    AutoCaller peerCaller (m->pPeer);
    639735    AssertComRCReturnVoid (peerCaller.rc());
    640736
    641     /* lock both for writing since we modify both (mPeer is "master" so locked
     737    /* lock both for writing since we modify both (m->pPeer is "master" so locked
    642738     * first) */
    643     AutoMultiWriteLock2 alock (mPeer, this);
    644 
    645     if (mData.isBackedUp())
    646     {
    647         mData.commit();
    648         if (mPeer)
     739    AutoMultiWriteLock2 alock (m->pPeer, this);
     740
     741    if (m->bd.isBackedUp())
     742    {
     743        m->bd.commit();
     744        if (m->pPeer)
    649745        {
    650746            // attach new data to the peer and reshare it
    651             mPeer->mData.attach (mData);
     747            m->pPeer->m->bd.attach (m->bd);
    652748        }
    653749    }
    … …  
    668764
    669765    /* sanity too */
    670     AutoCaller peerCaller (mPeer);
     766    AutoCaller peerCaller (m->pPeer);
    671767    AssertComRCReturnVoid (peerCaller.rc());
    672768
    673     /* peer is not modified, lock it for reading (mPeer is "master" so locked
     769    /* peer is not modified, lock it for reading (m->pPeer is "master" so locked
    674770     * first) */
    675     AutoMultiLock2 alock (mPeer->rlock(), this->wlock());
    676 
    677     if (mData.isShared())
    678     {
    679         if (!mData.isBackedUp())
    680             mData.backup();
    681 
    682         mData.commit();
    683     }
    684 
    685     unconst(mPeer).setNull();
     771    AutoMultiLock2 alock (m->pPeer->rlock(), this->wlock());
     772
     773    if (m->bd.isShared())
     774    {
     775        if (!m->bd.isBackedUp())
     776            m->bd.backup();
     777
     778        m->bd.commit();
     779    }
     780
     781    unconst(m->pPeer).setNull();
     782}
     783
     784const ComObjPtr<Machine, ComWeakRef>& StorageController::getMachine()
     785{
     786    return m->pParent;
     787}
     788
     789ComObjPtr<StorageController> StorageController::getPeer()
     790{
     791    return m->pPeer;
    686792}
    687793
    688794// private methods
    689795/////////////////////////////////////////////////////////////////////////////
     796
     797
    690798/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/USBDeviceImpl.cpp

    r25149 r25198  
    2323
    2424#include "USBDeviceImpl.h"
    25 
     25#include "Logging.h"
    2626
    2727// constructor / destructor

  • trunk/src/VBox/Main/include/StorageControllerImpl.h

    r25184 r25198  
    2727#include "VirtualBoxBase.h"
    2828
    29 #include <list>
    30 
    3129class Machine;
    3230
    … …  
    3735    VBOX_SCRIPTABLE_IMPL(IStorageController)
    3836{
    39 private:
    40 
    41     struct Data
    42     {
    43         /* Constructor. */
    44         Data() : mStorageBus (StorageBus_IDE),
    45                  mStorageControllerType (StorageControllerType_PIIX4),
    46                  mInstance (0),
    47                  mPortCount (2),
    48                  mPortIde0Master (0),
    49                  mPortIde0Slave (1),
    50                  mPortIde1Master (2),
    51                  mPortIde1Slave (3) { }
    52 
    53         bool operator== (const Data &that) const
    54         {
    55             return    this == &that
    56                    || (    (mStorageControllerType == that.mStorageControllerType)
    57                         && (strName           == that.strName)
    58                         && (mPortCount   == that.mPortCount)
    59                         && (mPortIde0Master == that.mPortIde0Master)
    60                         && (mPortIde0Slave  == that.mPortIde0Slave)
    61                         && (mPortIde1Master == that.mPortIde1Master)
    62                         && (mPortIde1Slave  == that.mPortIde1Slave));
    63         }
    64 
    65         /** Unique name of the storage controller. */
    66         Utf8Str strName;
    67         /** The connection type of thestorage controller. */
    68         StorageBus_T mStorageBus;
    69         /** Type of the Storage controller. */
    70         StorageControllerType_T mStorageControllerType;
    71         /** Instance number of the storage controller. */
    72         ULONG mInstance;
    73         /** Number of usable ports. */
    74         ULONG mPortCount;
    75 
    76         /** The following is only for the SATA controller atm. */
    77         /** Port which acts as primary master for ide emulation. */
    78         ULONG mPortIde0Master;
    79         /** Port which acts as primary slave for ide emulation. */
    80         ULONG mPortIde0Slave;
    81         /** Port which acts as secondary master for ide emulation. */
    82         ULONG mPortIde1Master;
    83         /** Port which acts as secondary slave for ide emulation. */
    84         ULONG mPortIde1Slave;
    85     };
    86 
    8737public:
    8838
    … …  
    9949    END_COM_MAP()
    10050
    101     DECLARE_EMPTY_CTOR_DTOR (StorageController)
     51    StorageController() { };
     52    ~StorageController() { };
    10253
    10354    HRESULT FinalConstruct();
    … …  
    13586    // public methods only for internal purposes
    13687
    137     const Utf8Str &name() const { return mData->strName; }
    138     StorageControllerType_T controllerType() const { return mData->mStorageControllerType; }
    139     StorageBus_T storageBus() const { return mData->mStorageBus; }
    140     ULONG instance() const { return mData->mInstance; }
     88    const Utf8Str &getName() const;
     89    StorageControllerType_T getControllerType() const;
     90    StorageBus_T getStorageBus() const;
     91    ULONG getInstance() const;
    14192
    142     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
    143     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
     93    bool isModified();
     94    bool isReallyModified();
    14495    bool rollback();
    14596    void commit();
    … …  
    151102
    152103    /** @note this doesn't require a read lock since mParent is constant. */
    153     const ComObjPtr<Machine, ComWeakRef> &parent() { return mParent; };
     104    const ComObjPtr<Machine, ComWeakRef>& getMachine();
    154105
    155     const Backupable<Data> &data() { return mData; }
    156     ComObjPtr<StorageController> peer() { return mPeer; }
     106    ComObjPtr<StorageController> getPeer();
    157107
    158108    // for VirtualBoxSupportErrorInfoImpl
    … …  
    163113    void printList();
    164114
    165     /** Parent object. */
    166     const ComObjPtr<Machine, ComWeakRef> mParent;
    167     /** Peer object. */
    168     const ComObjPtr<StorageController> mPeer;
    169     /** Data. */
    170     Backupable<Data> mData;
     115    struct Data;
     116    Data *m;
    171117};
    172118

  • trunk/src/VBox/Main/include/USBDeviceImpl.h

    r23223 r25198  
    2525
    2626#include "VirtualBoxBase.h"
    27 #include "Logging.h"
    28 
    2927
    3028/**
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette