VirtualBox

Changeset 25201 in vbox


Ignore:
Timestamp:
Dec 4, 2009 6:52:36 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
55682
Message:

Main: make BIOSSettings instance data private and make it use the XML settings struct for simplicity

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r24364 r25201  
    262262    {}
    263263
     264    bool operator==(const BIOSSettings &d) const
     265    {
     266        return (    this == &d
     267                 || (    fACPIEnabled        == d.fACPIEnabled
     268                      && fIOAPICEnabled      == d.fIOAPICEnabled
     269                      && fLogoFadeIn         == d.fLogoFadeIn
     270                      && fLogoFadeOut        == d.fLogoFadeOut
     271                      && ulLogoDisplayTime   == d.ulLogoDisplayTime
     272                      && strLogoImagePath    == d.strLogoImagePath
     273                      && biosBootMenuMode    == d.biosBootMenuMode
     274                      && fPXEDebugEnabled    == d.fPXEDebugEnabled
     275                      && llTimeOffset        == d.llTimeOffset)
     276               );
     277    }
     278
    264279    bool            fACPIEnabled,
    265280                    fIOAPICEnabled,

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

    r25149 r25201  
    2828#include <VBox/settings.h>
    2929
     30////////////////////////////////////////////////////////////////////////////////
     31//
     32// BIOSSettings private data definition
     33//
     34////////////////////////////////////////////////////////////////////////////////
     35
     36struct BIOSSettings::Data
     37{
     38    Data()
     39    { }
     40
     41    ComObjPtr<Machine, ComWeakRef>  pMachine;
     42    ComObjPtr<BIOSSettings>         pPeer;
     43
     44    // use the XML settings structure in the members for simplicity
     45    Backupable<settings::BIOSSettings> bd;
     46};
     47
    3048// constructor / destructor
    3149/////////////////////////////////////////////////////////////////////////////
    … …  
    4967 * @returns COM result indicator
    5068 */
    51 HRESULT BIOSSettings::init (Machine *aParent)
     69HRESULT BIOSSettings::init(Machine *aParent)
    5270{
    5371    LogFlowThisFuncEnter();
    … …  
    6078    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    6179
     80    m = new Data();
     81
    6282    /* share the parent weakly */
    63     unconst(mParent) = aParent;
    64 
    65     mData.allocate();
     83    unconst(m->pMachine) = aParent;
     84
     85    m->bd.allocate();
    6686
    6787    autoInitSpan.setSucceeded();
    … …  
    7999 *  it shares data with is destroyed.
    80100 */
    81 HRESULT BIOSSettings::init (Machine *aParent, BIOSSettings *that)
     101HRESULT BIOSSettings::init(Machine *aParent, BIOSSettings *that)
    82102{
    83103    LogFlowThisFuncEnter();
    … …  
    90110    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    91111
    92     mParent = aParent;
    93     mPeer = that;
    94 
    95     AutoWriteLock thatlock (that);
    96     mData.share (that->mData);
     112    m = new Data();
     113
     114    m->pMachine = aParent;
     115    m->pPeer = that;
     116
     117    AutoWriteLock thatlock(that);
     118    m->bd.share(that->m->bd);
    97119
    98120    autoInitSpan.setSucceeded();
    … …  
    107129 *  of the original object passed as an argument.
    108130 */
    109 HRESULT BIOSSettings::initCopy (Machine *aParent, BIOSSettings *that)
     131HRESULT BIOSSettings::initCopy(Machine *aParent, BIOSSettings *that)
    110132{
    111133    LogFlowThisFuncEnter();
    … …  
    118140    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    119141
    120     mParent = aParent;
     142    m = new Data();
     143
     144    m->pMachine = aParent;
    121145    // mPeer is left null
    122146
    123147    AutoWriteLock thatlock (that);
    124     mData.attachCopy (that->mData);
     148    m->bd.attachCopy(that->m->bd);
    125149
    126150    autoInitSpan.setSucceeded();
    … …  
    143167        return;
    144168
    145     mData.free();
    146 
    147     mPeer.setNull();
    148     mParent.setNull();
     169    m->bd.free();
     170
     171    m->pPeer.setNull();
     172    m->pMachine.setNull();
     173
     174    delete m;
     175    m = NULL;
    149176
    150177    LogFlowThisFuncLeave();
    … …  
    164191    AutoReadLock alock(this);
    165192
    166     *enabled = mData->mLogoFadeIn;
     193    *enabled = m->bd->fLogoFadeIn;
    167194
    168195    return S_OK;
    … …  
    175202
    176203    /* the machine needs to be mutable */
    177     Machine::AutoMutableStateDependency adep(mParent);
    178     if (FAILED(adep.rc())) return adep.rc();
    179 
    180     AutoWriteLock alock(this);
    181 
    182     mData.backup();
    183     mData->mLogoFadeIn = enable;
     204    Machine::AutoMutableStateDependency adep(m->pMachine);
     205    if (FAILED(adep.rc())) return adep.rc();
     206
     207    AutoWriteLock alock(this);
     208
     209    m->bd.backup();
     210    m->bd->fLogoFadeIn = enable;
    184211
    185212    return S_OK;
    … …  
    196223    AutoReadLock alock(this);
    197224
    198     *enabled = mData->mLogoFadeOut;
     225    *enabled = m->bd->fLogoFadeOut;
    199226
    200227    return S_OK;
    … …  
    207234
    208235    /* the machine needs to be mutable */
    209     Machine::AutoMutableStateDependency adep(mParent);
    210     if (FAILED(adep.rc())) return adep.rc();
    211 
    212     AutoWriteLock alock(this);
    213 
    214     mData.backup();
    215     mData->mLogoFadeOut = enable;
     236    Machine::AutoMutableStateDependency adep(m->pMachine);
     237    if (FAILED(adep.rc())) return adep.rc();
     238
     239    AutoWriteLock alock(this);
     240
     241    m->bd.backup();
     242    m->bd->fLogoFadeOut = enable;
    216243
    217244    return S_OK;
    … …  
    228255    AutoReadLock alock(this);
    229256
    230     *displayTime = mData->mLogoDisplayTime;
     257    *displayTime = m->bd->ulLogoDisplayTime;
    231258
    232259    return S_OK;
    … …  
    239266
    240267    /* the machine needs to be mutable */
    241     Machine::AutoMutableStateDependency adep(mParent);
    242     if (FAILED(adep.rc())) return adep.rc();
    243 
    244     AutoWriteLock alock(this);
    245 
    246     mData.backup();
    247     mData->mLogoDisplayTime = displayTime;
     268    Machine::AutoMutableStateDependency adep(m->pMachine);
     269    if (FAILED(adep.rc())) return adep.rc();
     270
     271    AutoWriteLock alock(this);
     272
     273    m->bd.backup();
     274    m->bd->ulLogoDisplayTime = displayTime;
    248275
    249276    return S_OK;
    … …  
    260287    AutoReadLock alock(this);
    261288
    262     mData->mLogoImagePath.cloneTo(imagePath);
     289    m->bd->strLogoImagePath.cloneTo(imagePath);
    263290    return S_OK;
    264291}
    … …  
    274301
    275302    /* the machine needs to be mutable */
    276     Machine::AutoMutableStateDependency adep(mParent);
    277     if (FAILED(adep.rc())) return adep.rc();
    278 
    279     AutoWriteLock alock(this);
    280 
    281     mData.backup();
    282     mData->mLogoImagePath = imagePath;
     303    Machine::AutoMutableStateDependency adep(m->pMachine);
     304    if (FAILED(adep.rc())) return adep.rc();
     305
     306    AutoWriteLock alock(this);
     307
     308    m->bd.backup();
     309    m->bd->strLogoImagePath = imagePath;
    283310
    284311    return S_OK;
    … …  
    295322    AutoReadLock alock(this);
    296323
    297     *bootMenuMode = mData->mBootMenuMode;
     324    *bootMenuMode = m->bd->biosBootMenuMode;
    298325    return S_OK;
    299326}
    … …  
    305332
    306333    /* the machine needs to be mutable */
    307     Machine::AutoMutableStateDependency adep(mParent);
    308     if (FAILED(adep.rc())) return adep.rc();
    309 
    310     AutoWriteLock alock(this);
    311 
    312     mData.backup();
    313     mData->mBootMenuMode = bootMenuMode;
     334    Machine::AutoMutableStateDependency adep(m->pMachine);
     335    if (FAILED(adep.rc())) return adep.rc();
     336
     337    AutoWriteLock alock(this);
     338
     339    m->bd.backup();
     340    m->bd->biosBootMenuMode = bootMenuMode;
    314341
    315342    return S_OK;
    … …  
    326353    AutoReadLock alock(this);
    327354
    328     *enabled = mData->mACPIEnabled;
     355    *enabled = m->bd->fACPIEnabled;
    329356
    330357    return S_OK;
    … …  
    337364
    338365    /* the machine needs to be mutable */
    339     Machine::AutoMutableStateDependency adep(mParent);
    340     if (FAILED(adep.rc())) return adep.rc();
    341 
    342     AutoWriteLock alock(this);
    343 
    344     mData.backup();
    345     mData->mACPIEnabled = enable;
     366    Machine::AutoMutableStateDependency adep(m->pMachine);
     367    if (FAILED(adep.rc())) return adep.rc();
     368
     369    AutoWriteLock alock(this);
     370
     371    m->bd.backup();
     372    m->bd->fACPIEnabled = enable;
    346373
    347374    return S_OK;
    … …  
    358385    AutoReadLock alock(this);
    359386
    360     *enabled = mData->mIOAPICEnabled;
     387    *enabled = m->bd->fIOAPICEnabled;
    361388
    362389    return S_OK;
    … …  
    369396
    370397    /* the machine needs to be mutable */
    371     Machine::AutoMutableStateDependency adep(mParent);
    372     if (FAILED(adep.rc())) return adep.rc();
    373 
    374     AutoWriteLock alock(this);
    375 
    376     mData.backup();
    377     mData->mIOAPICEnabled = enable;
     398    Machine::AutoMutableStateDependency adep(m->pMachine);
     399    if (FAILED(adep.rc())) return adep.rc();
     400
     401    AutoWriteLock alock(this);
     402
     403    m->bd.backup();
     404    m->bd->fIOAPICEnabled = enable;
    378405
    379406    return S_OK;
    … …  
    390417    AutoReadLock alock(this);
    391418
    392     *enabled = mData->mPXEDebugEnabled;
     419    *enabled = m->bd->fPXEDebugEnabled;
    393420
    394421    return S_OK;
    … …  
    401428
    402429    /* the machine needs to be mutable */
    403     Machine::AutoMutableStateDependency adep(mParent);
    404     if (FAILED(adep.rc())) return adep.rc();
    405 
    406     AutoWriteLock alock(this);
    407 
    408     mData.backup();
    409     mData->mPXEDebugEnabled = enable;
     430    Machine::AutoMutableStateDependency adep(m->pMachine);
     431    if (FAILED(adep.rc())) return adep.rc();
     432
     433    AutoWriteLock alock(this);
     434
     435    m->bd.backup();
     436    m->bd->fPXEDebugEnabled = enable;
    410437
    411438    return S_OK;
    … …  
    422449    AutoReadLock alock(this);
    423450
    424     *offset = mData->mTimeOffset;
     451    *offset = m->bd->llTimeOffset;
    425452
    426453    return S_OK;
    … …  
    433460
    434461    /* the machine needs to be mutable */
    435     Machine::AutoMutableStateDependency adep(mParent);
    436     if (FAILED(adep.rc())) return adep.rc();
    437 
    438     AutoWriteLock alock(this);
    439 
    440     mData.backup();
    441     mData->mTimeOffset = offset;
     462    Machine::AutoMutableStateDependency adep(m->pMachine);
     463    if (FAILED(adep.rc())) return adep.rc();
     464
     465    AutoWriteLock alock(this);
     466
     467    m->bd.backup();
     468    m->bd->llTimeOffset = offset;
    442469
    443470    return S_OK;
    … …  
    466493    AutoWriteLock alock(this);
    467494
    468     mData->mACPIEnabled = data.fACPIEnabled;
    469     mData->mIOAPICEnabled = data.fIOAPICEnabled;
    470 
    471     mData->mLogoFadeIn = data.fLogoFadeIn;
    472     mData->mLogoFadeOut = data.fLogoFadeOut;
    473     mData->mLogoDisplayTime = data.ulLogoDisplayTime;
    474     mData->mLogoImagePath = data.strLogoImagePath;
    475 
    476     mData->mBootMenuMode = data.biosBootMenuMode;
    477 
    478     mData->mPXEDebugEnabled = data.fPXEDebugEnabled;
    479     mData->mTimeOffset = data.llTimeOffset;
     495    // simply copy
     496    *m->bd.data() = data;
    480497
    481498    return S_OK;
    … …  
    496513    AutoReadLock alock(this);
    497514
    498     data.fACPIEnabled = !!mData->mACPIEnabled;
    499     data.fIOAPICEnabled = !!mData->mIOAPICEnabled;
    500 
    501     data.fLogoFadeIn = !!mData->mLogoFadeIn;
    502     data.fLogoFadeOut = !!mData->mLogoFadeOut;
    503     data.ulLogoDisplayTime = mData->mLogoDisplayTime;
    504     data.strLogoImagePath = mData->mLogoImagePath;
    505 
    506     data.biosBootMenuMode = mData->mBootMenuMode;
    507     data.fPXEDebugEnabled = !!mData->mPXEDebugEnabled;
    508     data.llTimeOffset = mData->mTimeOffset;
    509 
    510     return S_OK;
     515    data = *m->bd.data();
     516
     517    return S_OK;
     518}
     519
     520bool BIOSSettings::isModified()
     521{
     522    AutoReadLock alock (this);
     523    return m->bd.isBackedUp();
     524}
     525
     526bool BIOSSettings::isReallyModified()
     527{
     528    AutoReadLock alock (this);
     529    return m->bd.hasActualChanges();
     530}
     531
     532void BIOSSettings::rollback()
     533{
     534    AutoWriteLock alock (this);
     535    m->bd.rollback();
    511536}
    512537
    … …  
    515540    /* sanity */
    516541    AutoCaller autoCaller(this);
    517     AssertComRCReturnVoid (autoCaller.rc());
     542    AssertComRCReturnVoid(autoCaller.rc());
    518543
    519544    /* sanity too */
    520     AutoCaller peerCaller (mPeer);
    521     AssertComRCReturnVoid (peerCaller.rc());
     545    AutoCaller peerCaller(m->pPeer);
     546    AssertComRCReturnVoid(peerCaller.rc());
    522547
    523548    /* lock both for writing since we modify both (mPeer is "master" so locked
    524549     * first) */
    525     AutoMultiWriteLock2 alock (mPeer, this);
    526 
    527     if (mData.isBackedUp())
     550    AutoMultiWriteLock2 alock(m->pPeer, this);
     551
     552    if (m->bd.isBackedUp())
    528553    {
    529         mData.commit();
    530         if (mPeer)
     554        m->bd.commit();
     555        if (m->pPeer)
    531556        {
    532557            /* attach new data to the peer and reshare it */
    533             AutoWriteLock peerlock (mPeer);
    534             mPeer->mData.attach (mData);
     558            AutoWriteLock peerlock(m->pPeer);
     559            m->pPeer->m->bd.attach(m->bd);
    535560        }
    536561    }
    … …  
    551576    /* peer is not modified, lock it for reading (aThat is "master" so locked
    552577     * first) */
    553     AutoMultiLock2 alock (aThat->rlock(), this->wlock());
     578    AutoMultiLock2 alock(aThat->rlock(), this->wlock());
    554579
    555580    /* this will back up current data */
    556     mData.assignCopy (aThat->mData);
     581    m->bd.assignCopy(aThat->m->bd);
    557582}
    558583
    … …  
    568593
    569594    /* Initialize default BIOS settings here */
    570     mData->mIOAPICEnabled = aOsType->recommendedIOAPIC();
    571 }
     595    m->bd->fIOAPICEnabled = aOsType->recommendedIOAPIC();
     596}
     597
    572598/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

    r24989 r25201  
    4242{
    4343public:
    44 
    45     struct Data
    46     {
    47         Data()
    48         {
    49             mLogoFadeIn = true;
    50             mLogoFadeOut = true;
    51             mLogoDisplayTime = 0;
    52             mBootMenuMode = BIOSBootMenuMode_MessageAndMenu;
    53             mACPIEnabled = true;
    54             mIOAPICEnabled = false;
    55             mPXEDebugEnabled = false;
    56             mTimeOffset = 0;
    57         }
    58 
    59         bool operator== (const Data &that) const
    60         {
    61             return this == &that ||
    62                    (mLogoFadeIn         == that.mLogoFadeIn &&
    63                     mLogoFadeOut        == that.mLogoFadeOut &&
    64                     mLogoDisplayTime    == that.mLogoDisplayTime &&
    65                     mLogoImagePath      == that.mLogoImagePath &&
    66                     mBootMenuMode       == that.mBootMenuMode &&
    67                     mACPIEnabled        == that.mACPIEnabled &&
    68                     mIOAPICEnabled      == that.mIOAPICEnabled &&
    69                     mPXEDebugEnabled    == that.mPXEDebugEnabled &&
    70                     mTimeOffset         == that.mTimeOffset);
    71         }
    72 
    73         BOOL                mLogoFadeIn;
    74         BOOL                mLogoFadeOut;
    75         ULONG               mLogoDisplayTime;
    76         Bstr                mLogoImagePath;
    77         BIOSBootMenuMode_T  mBootMenuMode;
    78         BOOL                mACPIEnabled;
    79         BOOL                mIOAPICEnabled;
    80         BOOL                mPXEDebugEnabled;
    81         LONG64              mTimeOffset;
    82     };
    83 
    8444    DECLARE_NOT_AGGREGATABLE(BIOSSettings)
    8545
    … …  
    12585    HRESULT saveSettings(settings::BIOSSettings &data);
    12686
    127     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
    128     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
    129     void rollback() { AutoWriteLock alock (this); mData.rollback(); }
     87    bool isModified();
     88    bool isReallyModified();
     89    void rollback();
    13090    void commit();
    13191    void copyFrom (BIOSSettings *aThat);
    … …  
    13696
    13797private:
    138 
    139     ComObjPtr<Machine, ComWeakRef> mParent;
    140     ComObjPtr<BIOSSettings> mPeer;
    141     Backupable<Data> mData;
     98    struct Data;
     99    Data *m;
    142100};
    143101
Note: See TracChangeset for help on using the changeset viewer.

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