Changeset 25200 in vbox for trunk/src/VBox/Main

Timestamp:

Dec 4, 2009 6:19:05 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

55681

Message:

Main: make MediumAttachment instance data private

Location:

trunk/src/VBox/Main

Files:

• HostImpl.cpp (modified) (1 diff)
• MediumAttachmentImpl.cpp (modified) (5 diffs)
• SnapshotImpl.cpp (modified) (1 diff)
• include/MediumAttachmentImpl.h (modified) (5 diffs)
• include/MediumImpl.h (modified) (1 diff)
• include/VirtualBoxBase.h (modified) (1 diff)

trunk/src/VBox/Main/HostImpl.cpp

@@ -30 +30 @@
 #endif // VBOX_WITH_USB
 
+#include "MediumImpl.h"
 #include "HostPower.h"
 

trunk/src/VBox/Main/MediumAttachmentImpl.cpp

@@ -22 +22 @@
 #include "MediumAttachmentImpl.h"
 #include "MachineImpl.h"
+#include "MediumImpl.h"
 #include "Global.h"
 
 #include "Logging.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// private member data definition
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct BackupableMediumAttachmentData
+{
+    BackupableMediumAttachmentData()
+        : lPort(0),
+          lDevice(0),
+          type(DeviceType_Null),
+          fPassthrough(false),
+          fImplicit(false)
+    { }
+
+    bool operator==(const BackupableMediumAttachmentData &that) const
+    {
+        return    this == &that
+               || (fPassthrough == that.fPassthrough);
+    }
+
+    ComObjPtr<Medium>   pMedium;
+    /* Since MediumAttachment is not a first class citizen when it
+     * comes to managing settings, having a reference to the storage
+     * controller will not work - when settings are changed it will point
+     * to the old, uninitialized instance. Changing this requires
+     * substantial changes to MediumImpl.cpp. */
+    const Bstr          bstrControllerName;
+    const LONG          lPort;
+    const LONG          lDevice;
+    const DeviceType_T  type;
+    bool                fPassthrough : 1;
+    bool                fImplicit : 1;
+};
+
+struct MediumAttachment::Data
+{
+    Data()
+    { }
+
+    /** Reference to Machine object, for checking mutable state. */
+    const ComObjPtr<Machine, ComWeakRef> pMachine;
+    /* later: const ComObjPtr<MediumAttachment> mPeer; */
+
+    Backupable<BackupableMediumAttachmentData> bd;
+};
 
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
-
-DEFINE_EMPTY_CTOR_DTOR(MediumAttachment)
 
 HRESULT MediumAttachment::FinalConstruct()
@@ -75 +122 @@
     AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
-    unconst(mParent) = aParent;
-
-    m.allocate();
-    m->medium = aMedium;
-    unconst(m->controllerName) = aControllerName;
-    unconst(m->port)   = aPort;
-    unconst(m->device) = aDevice;
-    unconst(m->type)   = aType;
-    unconst(m->passthrough) = false;
-
-    m->implicit = aImplicit;
+    m = new Data();
+
+    unconst(m->pMachine) = aParent;
+
+    m->bd.allocate();
+    m->bd->pMedium = aMedium;
+    unconst(m->bd->bstrControllerName) = aControllerName;
+    unconst(m->bd->lPort)   = aPort;
+    unconst(m->bd->lDevice) = aDevice;
+    unconst(m->bd->type)   = aType;
+
+    m->bd->fPassthrough = false;
+    m->bd->fImplicit = aImplicit;
 
     /* Confirm a successful initialization when it's the case */
@@ -116 +165 @@
         return;
 
-    m.free();
-
-    unconst(mParent).setNull();
-
-    LogFlowThisFuncLeave();
+    m->bd.free();
+
+    unconst(m->pMachine).setNull();
+
+    delete m;
+    m = NULL;
+
+    LogFlowThisFuncLeave();
+}
+
+// IHardDiskAttachment properties
+/////////////////////////////////////////////////////////////////////////////
+
+STDMETHODIMP MediumAttachment::COMGETTER(Medium)(IMedium **aHardDisk)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aHardDisk);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this);
+
+    m->bd->pMedium.queryInterfaceTo(aHardDisk);
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+STDMETHODIMP MediumAttachment::COMGETTER(Controller)(BSTR *aController)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aController);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* m->controller is constant during life time, no need to lock */
+    m->bd->bstrControllerName.cloneTo(aController);
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+STDMETHODIMP MediumAttachment::COMGETTER(Port)(LONG *aPort)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aPort);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* m->bd->port is constant during life time, no need to lock */
+    *aPort = m->bd->lPort;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+STDMETHODIMP MediumAttachment::COMGETTER(Device)(LONG *aDevice)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aDevice);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* m->bd->device is constant during life time, no need to lock */
+    *aDevice = m->bd->lDevice;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+STDMETHODIMP MediumAttachment::COMGETTER(Type)(DeviceType_T *aType)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aType);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* m->bd->type is constant during life time, no need to lock */
+    *aType = m->bd->type;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+STDMETHODIMP MediumAttachment::COMGETTER(Passthrough)(BOOL *aPassthrough)
+{
+    LogFlowThisFuncEnter();
+
+    CheckComArgOutPointerValid(aPassthrough);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock lock(this);
+
+    *aPassthrough = m->bd->fPassthrough;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
 }
 
@@ -138 +291 @@
     bool changed = false;
 
-    if (m.isBackedUp())
+    if (m->bd.isBackedUp())
     {
         /* we need to check all data to see whether anything will be changed
          * after rollback */
-        changed = m.hasActualChanges();
-        m.rollback();
+        changed = m->bd.hasActualChanges();
+        m->bd.rollback();
     }
 
@@ -163 +316 @@
     AutoWriteLock alock(this);
 
-    if (m.isBackedUp())
-        m.commit();
-
-    LogFlowThisFuncLeave();
-}
-
-
-// IHardDiskAttachment properties
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP MediumAttachment::COMGETTER(Medium)(IMedium **aHardDisk)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aHardDisk);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this);
-
-    m->medium.queryInterfaceTo(aHardDisk);
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Controller)(BSTR *aController)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aController);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* m->controller is constant during life time, no need to lock */
-    m->controllerName.cloneTo(aController);
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Port)(LONG *aPort)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aPort);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* m->port is constant during life time, no need to lock */
-    *aPort = m->port;
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Device)(LONG *aDevice)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aDevice);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* m->device is constant during life time, no need to lock */
-    *aDevice = m->device;
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Type)(DeviceType_T *aType)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* m->type is constant during life time, no need to lock */
-    *aType = m->type;
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Passthrough)(BOOL *aPassthrough)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aPassthrough);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    if (m->bd.isBackedUp())
+        m->bd.commit();
+
+    LogFlowThisFuncLeave();
+}
+
+bool MediumAttachment::isImplicit() const
+{
+    return m->bd->fImplicit;
+}
+
+void MediumAttachment::setImplicit(bool aImplicit)
+{
+    m->bd->fImplicit = aImplicit;
+}
+
+const ComObjPtr<Medium>& MediumAttachment::getMedium() const
+{
+    return m->bd->pMedium;
+}
+
+Bstr MediumAttachment::getControllerName() const
+{
+    return m->bd->bstrControllerName;
+}
+
+LONG MediumAttachment::getPort() const
+{
+    return m->bd->lPort;
+}
+
+LONG MediumAttachment::getDevice() const
+{
+    return m->bd->lDevice;
+}
+
+DeviceType_T MediumAttachment::getType() const
+{
+    return m->bd->type;
+}
+
+bool MediumAttachment::getPassthrough() const
+{
     AutoReadLock lock(this);
-
-    *aPassthrough = m->passthrough;
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
+    return m->bd->fPassthrough;
+}
+
+bool MediumAttachment::matches(CBSTR aControllerName, LONG aPort, LONG aDevice)
+{
+    return (    aControllerName == m->bd->bstrControllerName
+             && aPort == m->bd->lPort
+             && aDevice == m->bd->lDevice);
+}
+
+/** Must be called from under this object's write lock. */
+void MediumAttachment::updateMedium(const ComObjPtr<Medium> &aMedium, bool aImplicit)
+{
+    m->bd.backup();
+    m->bd->pMedium = aMedium;
+    m->bd->fImplicit = aImplicit;
+}
+
+/** Must be called from under this object's write lock. */
+void MediumAttachment::updatePassthrough(bool aPassthrough)
+{
+    m->bd.backup();
+    m->bd->fPassthrough = aPassthrough;
+}
+

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -23 +23 @@
 
 #include "MachineImpl.h"
+#include "MediumImpl.h"
 #include "Global.h"
 

trunk/src/VBox/Main/include/MediumAttachmentImpl.h

@@ -25 +25 @@
 #include "VirtualBoxBase.h"
 
-#include "MediumImpl.h"
-
 class Machine;
 class Medium;
@@ -48 +46 @@
     END_COM_MAP()
 
-    DECLARE_EMPTY_CTOR_DTOR(MediumAttachment)
+    MediumAttachment() { };
+    ~MediumAttachment() { };
 
     // public initializer/uninitializer for internal purposes only
@@ -63 +62 @@
     void FinalRelease();
 
-    bool rollback();
-    void commit();
-
     // IMediumAttachment properties
     STDMETHOD(COMGETTER(Medium))(IMedium **aMedium);
@@ -74 +70 @@
     STDMETHOD(COMGETTER(Passthrough))(BOOL *aPassthrough);
 
-    // unsafe inline public methods for internal purposes only (ensure there is
+    // public internal methods
+    bool rollback();
+    void commit();
+
+    // unsafe public methods for internal purposes only (ensure there is
     // a caller and a read lock before calling them!)
+    bool isImplicit() const;
+    void setImplicit(bool aImplicit);
 
-    bool isImplicit() const { return m->implicit; }
-    void setImplicit(bool aImplicit) { m->implicit = aImplicit; }
+    const ComObjPtr<Medium>& getMedium() const;
+    Bstr getControllerName() const;
+    LONG getPort() const;
+    LONG getDevice() const;
+    DeviceType_T getType() const;
+    bool getPassthrough() const;
 
-    const ComObjPtr<Medium>& getMedium() const { return m->medium; }
-    Bstr getControllerName() const { return m->controllerName; }
-    LONG getPort() const { return m->port; }
-    LONG getDevice() const { return m->device; }
-    DeviceType_T getType() const { return m->type; }
-    bool getPassthrough() const { AutoReadLock lock(this); return m->passthrough; }
-
-    bool matches(CBSTR aControllerName, LONG aPort, LONG aDevice)
-    {
-        return (    aControllerName == m->controllerName
-                 && aPort == m->port
-                 && aDevice == m->device);
-    }
+    bool matches(CBSTR aControllerName, LONG aPort, LONG aDevice);
 
     /** Must be called from under this object's write lock. */
-    void updateMedium(const ComObjPtr<Medium> &aMedium, bool aImplicit)
-    {
-        m.backup();
-        m->medium = aMedium;
-        m->implicit = aImplicit;
-    }
+    void updateMedium(const ComObjPtr<Medium> &aMedium, bool aImplicit);
 
     /** Must be called from under this object's write lock. */
-    void updatePassthrough(bool aPassthrough)
-    {
-        m.backup();
-        m->passthrough = aPassthrough;
-    }
+    void updatePassthrough(bool aPassthrough);
 
     /** Get a unique and somewhat descriptive name for logging. */
@@ -116 +101 @@
 
 private:
-
-    /** Reference to Machine object, for checking mutable state. */
-    const ComObjPtr<Machine, ComWeakRef> mParent;
-    /* later: const ComObjPtr<MediumAttachment> mPeer; */
-
-    struct Data
-    {
-        Data() : port(0), device(0), type(DeviceType_Null),
-                 passthrough(false), implicit(false) {}
-
-        bool operator== (const Data &that) const
-        {
-            return   this == &that
-                   || (passthrough == that.passthrough);
-        }
-
-        ComObjPtr<Medium> medium;
-        /* Since MediumAttachment is not a first class citizen when it
-         * comes to managing settings, having a reference to the storage
-         * controller will not work - when settings are changed it will point
-         * to the old, uninitialized instance. Changing this requires
-         * substantial changes to MediumImpl.cpp. */
-        const Bstr controllerName;
-        const LONG port;
-        const LONG device;
-        const DeviceType_T type;
-        bool passthrough : 1;
-        bool implicit : 1;
-    };
-
-    Backupable<Data> m;
+    struct Data;
+    Data *m;
 
     Utf8Str mLogName;                   /**< For logging purposes */

trunk/src/VBox/Main/include/MediumImpl.h

@@ -25 +25 @@
 
 #include "VirtualBoxBase.h"
-
-#include <VBox/com/SupportErrorInfo.h>
 
 class VirtualBox;

trunk/src/VBox/Main/include/VirtualBoxBase.h

@@ -29 +29 @@
 
 #include "VBox/com/ErrorInfo.h"
+#include <VBox/com/SupportErrorInfo.h>
 
 #include "VBox/com/VirtualBox.h"