VirtualBox

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


Ignore:
Timestamp:
Apr 11, 2013 5:55:28 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84955
Message:

Main: Code generator for (xp)com implementations, including logging and parameter conversion, so far only used by MediumFormat.

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/Makefile.kmk

    r45415 r45491  
    162162docs:                $(PATH_TARGET)/docs.Main
    163163endif
     164
     165
     166#
     167# Generate library with API class wrappers from the XIDL file.
     168#
     169LIBRARIES += VBoxAPIWrap
     170VBoxAPIWrap_TEMPLATE        = VBOXMAINLIB
     171VBoxAPIWrap_SOURCES         = $(VBoxAPIWrap_GENERATEDCPP)
     172VBoxAPIWrap_GENERATEDCPP    = $(filter %.cpp,$(VBoxAPIWrap_GENERATEDSOURCES))
     173VBoxAPIWrap_GENERATEDSOURCES = $(addprefix $(VBoxAPIWrap_0_OUTDIR)/,$(VBoxAPIWrap_VBOX_APIWRAPPERFILES))
     174VBoxAPIWrap_RAWSRC          = \
     175        $(VBoxAPIWrap_0_OUTDIR)/apiwrappers
     176VBoxAPIWrap_XSLT            = \
     177        $(VBOX_PATH_MAIN_SRC)/idl/apiwrap-server.xsl
     178VBoxAPIWrap_DEFS.win.x86 += _WIN32_WINNT=0x0500
     179VBoxAPIWrap_DEFS.win.amd64 += _WIN32_WINNT=0x0510
     180VBoxAPIWrap_INCS           += \
     181        include
     182VBoxAPIWrap_CLEAN           = \
     183        $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.cpp) \
     184        $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.h) \
     185        $(VBoxAPIWrap_RAWSRC)
     186VBoxAPIWrap_KMK = $(PATH_OUT)/vboxapiwrap.kmk
     187include $(VBoxAPIWrap_KMK)
    164188
    165189
    … …  
    256280VBoxSVC_CXXFLAGS = $(filter-out -Wno-unused,$(TEMPLATE_VBOXMAINEXE_CXXFLAGS))
    257281
     282.PRECIOUS: C:/projects/vbox/out/win.x86/debug/obj/VBoxSVC/VBoxSVC.rsp
     283
    258284VBoxSVC_INCS = \
    259285        include \
    260286        $(VBoxSVC_0_OUTDIR) \
    261287        $(dir $(VBOX_XML_SCHEMADEFS_H)) \
     288        $(VBoxAPIWrap_0_OUTDIR) \
    262289        .
    263290VBoxSVC_INCS.win = \
    … …  
    269296
    270297VBoxSVC_LIBS += \
     298        $(PATH_STAGE_LIB)/VBoxAPIWrap$(VBOX_SUFF_LIB) \
    271299        $(PATH_STAGE_LIB)/SSMStandalone$(VBOX_SUFF_LIB) \
    272300        $(LIB_DDU)
    … …  
    547575        include \
    548576        $(VBoxC_0_OUTDIR) \
     577        $(VBoxAPIWrap_0_OUTDIR) \
    549578        $(dir $(VBOX_XML_SCHEMADEFS_H))
    550579VBoxC_INCS.win      = \
    … …  
    866895                | $(VBOX_JMSCOM_GEN)/java/
    867896        $(call MSG_L1,Generating Java MSCOM glue files from XIDL)
    868         $(QUIET)$(RM) -f $(wildcard $(VBOX_JMSCOM_GEN)/java/*.java)
     897        $(QUIET)$(RM) -f $(VBOX_JMSCOM_GEN)/java/*.java
    869898        $(QUIET)$(VBOX_XSLTPROC) \
    870899              --stringparam G_vboxApiSuffix $(VBOX_API_SUFFIX) \
    … …  
    900929        $(VBOX_PATH_MAIN_SRC)/glue/tests/Makefile=>Makefile
    901930
     931# moved those rules to the end so that VBoxAPIWrap_0_OUTDIR can be expanded without $$ trickery
     932$(VBoxAPIWrap_RAWSRC) \
     933+| $(VBoxAPIWrap_GENERATEDSOURCES): \
     934                $(VBOX_XIDL_FILE) \
     935                $(VBoxAPIWrap_XSLT) \
     936                $(VBOX_FILESPLIT) \
     937                | $$(dir $$@)
     938        $(call MSG_L1,Generating C++ Server API wrapper files from XIDL)
     939        $(QUIET)$(RM) -f $(filter-out $(VBoxAPIWrap_GENERATEDSOURCES),$(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.cpp) $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.h))
     940        $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly "" -o $@ $(VBoxAPIWrap_XSLT) $<
     941        $(QUIET)$(VBOX_FILESPLIT) $@ $(VBoxAPIWrap_0_OUTDIR)
     942
     943$(VBoxAPIWrap_KMK).ts +| $(VBoxAPIWrap_KMK): $(VBOX_XIDL_FILE) $(VBoxAPIWrap_XSLT)
     944        $(call MSG_GENERATE,,$(VBoxAPIWrap_KMK))
     945        $(QUIET)$(RM) -f $@
     946        $(QUIET)$(MKDIR) -p $(@D)
     947        $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly VBoxAPIWrap_VBOX_APIWRAPPERFILES -o $@ $(VBoxAPIWrap_XSLT) $<
     948        $(QUIET)$(CP) --changed -fv $@ $(VBoxAPIWrap_KMK)
     949
    902950updatenls::
    903951        $(VBOX_LUPDATE) $(VBoxSVC_SOURCES) $(VBoxSVC_VBOX_HEADERS) -ts $(VBoxSVC_VBOX_TRANSLATIONS)

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

    r44528 r45491  
    33/** @file
    44 *
    5  * VirtualBox COM class implementation
     5 * MediumFormat COM class implementation
    66 */
    77
    … …  
    1818 */
    1919
    20 #ifndef ____H_MEDIUMFORMAT
    21 #define ____H_MEDIUMFORMAT
     20#ifndef MEDIUMFORMAT_IMPL_H_
     21#define MEDIUMFORMAT_IMPL_H_
    2222
    23 #include "VirtualBoxBase.h"
     23#include "MediumFormatWrap.h"
    2424
    25 #include <VBox/com/array.h>
    26 
    27 #include <list>
    2825
    2926struct VDBACKENDINFO;
    … …  
    3936 */
    4037class ATL_NO_VTABLE MediumFormat :
    41     public VirtualBoxBase,
    42     VBOX_SCRIPTABLE_IMPL(IMediumFormat)
     38    public MediumFormatWrap
    4339{
    4440public:
    … …  
    5349    };
    5450
    55     typedef std::list<Utf8Str>      StrList;
    56     typedef std::list<DeviceType_T> DeviceTypeList;
    57     typedef std::list<Property>     PropertyList;
    58 
    59     struct Data
    60     {
    61         Data() : capabilities((MediumFormatCapabilities_T)0) {}
    62 
    63         const Utf8Str        strId;
    64         const Utf8Str        strName;
    65         const StrList        llFileExtensions;
    66         const DeviceTypeList llDeviceTypes;
    67         const MediumFormatCapabilities_T capabilities;
    68         const PropertyList   llProperties;
    69     };
    70 
    71     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumFormat, IMediumFormat)
    72 
    73     DECLARE_NOT_AGGREGATABLE(MediumFormat)
    74 
    75     DECLARE_PROTECT_FINAL_CONSTRUCT()
    76 
    77     BEGIN_COM_MAP(MediumFormat)
    78         VBOX_DEFAULT_INTERFACE_ENTRIES(IMediumFormat)
    79     END_COM_MAP()
     51    typedef std::vector<Property> PropertyArray;
     52    typedef std::vector<com::Utf8Str> StrArray;
    8053
    8154    DECLARE_EMPTY_CTOR_DTOR(MediumFormat)
    … …  
    8861    void uninit();
    8962
    90     // IMediumFormat properties
    91     STDMETHOD(COMGETTER(Id))(BSTR *aId);
    92     STDMETHOD(COMGETTER(Name))(BSTR *aName);
    93     STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(MediumFormatCapabilities_T, aCaps));
    94 
    95     // IMediumFormat methods
    96     STDMETHOD(DescribeFileExtensions)(ComSafeArrayOut(BSTR, aFileExtensions),
    97                                       ComSafeArrayOut(DeviceType_T, aDeviceTypes));
    98     STDMETHOD(DescribeProperties)(ComSafeArrayOut(BSTR, aNames),
    99                                   ComSafeArrayOut(BSTR, aDescriptions),
    100                                   ComSafeArrayOut(DataType_T, aTypes),
    101                                   ComSafeArrayOut(ULONG, aFlags),
    102                                   ComSafeArrayOut(BSTR, aDefaults));
    103 
    104     // public methods only for internal purposes
    105 
    10663    // public methods for internal purposes only
    10764    // (ensure there is a caller and a read lock before calling them!)
    10865
    10966    /** Const, no need to lock */
    110     const Utf8Str& getId() const { return m.strId; }
     67    const Utf8Str &i_getId() const { return m.strId; }
    11168    /** Const, no need to lock */
    112     const StrList& getFileExtensions() const { return m.llFileExtensions; }
     69    const StrArray &i_getFileExtensions() const { return m.maFileExtensions; }
    11370    /** Const, no need to lock */
    114     MediumFormatCapabilities_T getCapabilities() const { return m.capabilities; }
     71    MediumFormatCapabilities_T i_getCapabilities() const { return m.capabilities; }
    11572    /** Const, no need to lock */
    116     const PropertyList& getProperties() const { return m.llProperties; }
     73    const PropertyArray &i_getProperties() const { return m.maProperties; }
    11774
    11875private:
     76
     77    // wrapped IMediumFormat properties
     78    HRESULT getId(com::Utf8Str &aId);
     79    HRESULT getName(com::Utf8Str &aName);
     80    HRESULT getCapabilities(std::vector<MediumFormatCapabilities_T> &aCapabilities);
     81
     82    // wrapped IMediumFormat methods
     83    HRESULT describeFileExtensions(std::vector<com::Utf8Str> &aExtensions,
     84                                   std::vector<DeviceType_T> &aTypes);
     85    HRESULT describeProperties(std::vector<com::Utf8Str> &aNames,
     86                               std::vector<com::Utf8Str> &aDescriptions,
     87                               std::vector<DataType_T> &aTypes,
     88                               std::vector<ULONG> &aFlags,
     89                               std::vector<com::Utf8Str> &aDefaults);
     90
     91    // types
     92    typedef std::vector<DeviceType_T> DeviceTypeArray;
     93
     94    // data
     95    struct Data
     96    {
     97        Data() : capabilities((MediumFormatCapabilities_T)0) {}
     98
     99        const Utf8Str        strId;
     100        const Utf8Str        strName;
     101        const StrArray       maFileExtensions;
     102        const DeviceTypeArray maDeviceTypes;
     103        const MediumFormatCapabilities_T capabilities;
     104        const PropertyArray  maProperties;
     105    };
    119106
    120107    Data m;
    121108};
    122109
    123 #endif // ____H_MEDIUMFORMAT
     110#endif // MEDIUMFORMAT_IMPL_H_
    124111
    125112/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/src-server/MediumFormatImpl.cpp

    r44528 r45491  
    22/** @file
    33 *
    4  * VirtualBox COM class implementation
     4 * MediumFormat COM class implementation
    55 */
    66
    … …  
    7676            DeviceType_T devType;
    7777
    78             unconst(m.llFileExtensions).push_back(papExtension->pszExtension);
     78            unconst(m.maFileExtensions).push_back(papExtension->pszExtension);
    7979
    8080            switch(papExtension->enmType)
    … …  
    9494            }
    9595
    96             unconst(m.llDeviceTypes).push_back(devType);
     96            unconst(m.maDeviceTypes).push_back(devType);
    9797            ++papExtension;
    9898        }
    … …  
    157157                                    flags,
    158158                                    defaultValue };
    159             unconst(m.llProperties).push_back(prop);
     159            unconst(m.maProperties).push_back(prop);
    160160            ++pa;
    161161        }
    … …  
    181181        return;
    182182
    183     unconst(m.llProperties).clear();
    184     unconst(m.llFileExtensions).clear();
    185     unconst(m.llDeviceTypes).clear();
     183    unconst(m.maProperties).clear();
     184    unconst(m.maFileExtensions).clear();
     185    unconst(m.maDeviceTypes).clear();
    186186    unconst(m.capabilities) = (MediumFormatCapabilities_T)0;
    187187    unconst(m.strName).setNull();
    … …  
    192192/////////////////////////////////////////////////////////////////////////////
    193193
    194 STDMETHODIMP MediumFormat::COMGETTER(Id)(BSTR *aId)
    195 {
    196     CheckComArgOutPointerValid(aId);
    197 
    198     AutoCaller autoCaller(this);
    199     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    200 
    201     /* this is const, no need to lock */
    202     m.strId.cloneTo(aId);
    203 
    204     return S_OK;
    205 }
    206 
    207 STDMETHODIMP MediumFormat::COMGETTER(Name)(BSTR *aName)
    208 {
    209     CheckComArgOutPointerValid(aName);
    210 
    211     AutoCaller autoCaller(this);
    212     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    213 
    214     /* this is const, no need to lock */
    215     m.strName.cloneTo(aName);
    216 
    217     return S_OK;
    218 }
    219 
    220 STDMETHODIMP MediumFormat::COMGETTER(Capabilities)(ComSafeArrayOut(MediumFormatCapabilities_T, aCaps))
    221 {
    222     CheckComArgOutSafeArrayPointerValid(aCaps);
    223 
    224     AutoCaller autoCaller(this);
    225     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    226 
    227     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    228 
    229     SafeArray<MediumFormatCapabilities_T> capabilities(sizeof(MediumFormatCapabilities_T)*8);
    230 
    231     for (ULONG i = 0; i < capabilities.size(); ++i)
    232     {
    233         ULONG temp = m.capabilities;
    234         temp &= 1<<i;
    235         capabilities [i] = (MediumFormatCapabilities_T)temp;
    236     }
    237 
    238     capabilities.detachTo(ComSafeArrayOutArg(aCaps));
    239 
    240     return S_OK;
    241 }
    242 
    243 STDMETHODIMP MediumFormat::DescribeFileExtensions(ComSafeArrayOut(BSTR, aFileExtensions),
    244                                                   ComSafeArrayOut(DeviceType_T, aDeviceTypes))
    245 {
    246     CheckComArgOutSafeArrayPointerValid(aFileExtensions);
    247 
    248     AutoCaller autoCaller(this);
    249     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    250 
    251     /* this is const, no need to lock */
    252     com::SafeArray<BSTR> fileExtentions(m.llFileExtensions.size());
    253     int i = 0;
    254     for (StrList::const_iterator it = m.llFileExtensions.begin();
    255          it != m.llFileExtensions.end();
    256          ++it, ++i)
    257         (*it).cloneTo(&fileExtentions[i]);
    258     fileExtentions.detachTo(ComSafeArrayOutArg(aFileExtensions));
    259 
    260     com::SafeArray<DeviceType_T> deviceTypes(m.llDeviceTypes.size());
    261     i = 0;
    262     for (DeviceTypeList::const_iterator it = m.llDeviceTypes.begin();
    263          it != m.llDeviceTypes.end();
    264          ++it, ++i)
    265         deviceTypes[i] = (*it);
    266     deviceTypes.detachTo(ComSafeArrayOutArg(aDeviceTypes));
    267 
    268     return S_OK;
    269 }
    270 
    271 STDMETHODIMP MediumFormat::DescribeProperties(ComSafeArrayOut(BSTR, aNames),
    272                                               ComSafeArrayOut(BSTR, aDescriptions),
    273                                               ComSafeArrayOut(DataType_T, aTypes),
    274                                               ComSafeArrayOut(ULONG, aFlags),
    275                                               ComSafeArrayOut(BSTR, aDefaults))
    276 {
    277     CheckComArgOutSafeArrayPointerValid(aNames);
    278     CheckComArgOutSafeArrayPointerValid(aDescriptions);
    279     CheckComArgOutSafeArrayPointerValid(aTypes);
    280     CheckComArgOutSafeArrayPointerValid(aFlags);
    281     CheckComArgOutSafeArrayPointerValid(aDefaults);
    282 
    283     AutoCaller autoCaller(this);
    284     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    285 
    286     /* this is const, no need to lock */
    287     size_t c = m.llProperties.size();
    288     com::SafeArray<BSTR>        propertyNames(c);
    289     com::SafeArray<BSTR>        propertyDescriptions(c);
    290     com::SafeArray<DataType_T>  propertyTypes(c);
    291     com::SafeArray<ULONG>       propertyFlags(c);
    292     com::SafeArray<BSTR>        propertyDefaults(c);
    293 
    294     int i = 0;
    295     for (PropertyList::const_iterator it = m.llProperties.begin();
    296          it != m.llProperties.end();
    297          ++it, ++i)
    298     {
    299         const Property &prop = (*it);
    300         prop.strName.cloneTo(&propertyNames[i]);
    301         prop.strDescription.cloneTo(&propertyDescriptions[i]);
    302         propertyTypes[i] = prop.type;
    303         propertyFlags[i] = prop.flags;
    304         prop.strDefaultValue.cloneTo(&propertyDefaults[i]);
    305     }
    306 
    307     propertyNames.detachTo(ComSafeArrayOutArg(aNames));
    308     propertyDescriptions.detachTo(ComSafeArrayOutArg(aDescriptions));
    309     propertyTypes.detachTo(ComSafeArrayOutArg(aTypes));
    310     propertyFlags.detachTo(ComSafeArrayOutArg(aFlags));
    311     propertyDefaults.detachTo(ComSafeArrayOutArg(aDefaults));
     194HRESULT MediumFormat::getId(com::Utf8Str &aId)
     195{
     196    /* this is const, no need to lock */
     197    aId = m.strId;
     198
     199    return S_OK;
     200}
     201
     202HRESULT MediumFormat::getName(com::Utf8Str &aName)
     203{
     204    /* this is const, no need to lock */
     205    aName = m.strName;
     206
     207    return S_OK;
     208}
     209
     210HRESULT MediumFormat::getCapabilities(std::vector<MediumFormatCapabilities_T> &aCapabilities)
     211{
     212    /* m.capabilities is const, no need to lock */
     213
     214    aCapabilities.resize(sizeof(MediumFormatCapabilities_T) * 8);
     215    size_t cCapabilities = 0;
     216    for (size_t i = 0; i < aCapabilities.size(); i++)
     217    {
     218        uint64_t tmp = m.capabilities;
     219        tmp &= 1ULL << i;
     220        if (tmp)
     221            aCapabilities[cCapabilities] = (MediumFormatCapabilities_T)tmp;
     222    }
     223    aCapabilities.resize(RT_MIN(cCapabilities, 1));
    312224
    313225    return S_OK;
    … …  
    317229/////////////////////////////////////////////////////////////////////////////
    318230
     231HRESULT MediumFormat::describeFileExtensions(std::vector<com::Utf8Str> &aExtensions,
     232                                             std::vector<DeviceType_T> &aTypes)
     233{
     234    /* this is const, no need to lock */
     235    aExtensions = m.maFileExtensions;
     236    aTypes = m.maDeviceTypes;
     237
     238    return S_OK;
     239}
     240
     241HRESULT MediumFormat::describeProperties(std::vector<com::Utf8Str> &aNames,
     242                                         std::vector<com::Utf8Str> &aDescriptions,
     243                                         std::vector<DataType_T> &aTypes,
     244                                         std::vector<ULONG> &aFlags,
     245                                         std::vector<com::Utf8Str> &aDefaults)
     246{
     247    /* this is const, no need to lock */
     248    size_t c = m.maProperties.size();
     249    aNames.resize(c);
     250    aDescriptions.resize(c);
     251    aTypes.resize(c);
     252    aFlags.resize(c);
     253    aDefaults.resize(c);
     254    for (size_t i = 0; i < c; i++)
     255    {
     256        const Property &prop = m.maProperties[i];
     257        aNames[i] = prop.strName;
     258        aDescriptions[i] = prop.strDescription;
     259        aTypes[i] = prop.type;
     260        aFlags[i] = prop.flags;
     261        aDefaults[i] = prop.strDefaultValue;
     262    }
     263
     264    return S_OK;
     265}
     266
    319267// public methods only for internal purposes
    320268/////////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Main/src-server/MediumImpl.cpp

    r45239 r45491  
    959959    if (FAILED(rc)) return rc;
    960960
    961     if (!(m->formatObj->getCapabilities() & (   MediumFormatCapabilities_CreateFixed
     961    if (!(m->formatObj->i_getCapabilities() & (   MediumFormatCapabilities_CreateFixed
    962962                                              | MediumFormatCapabilities_CreateDynamic))
    963963       )
    … …  
    12401240
    12411241    Utf8Str strFull;
    1242     if (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
     1242    if (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
    12431243    {
    12441244        // compose full path of the medium, if it's not fully qualified...
    … …  
    25172517
    25182518        if (    !(mediumVariantFlags & MediumVariant_Fixed)
    2519             &&  !(m->formatObj->getCapabilities() & MediumFormatCapabilities_CreateDynamic))
     2519            &&  !(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_CreateDynamic))
    25202520            throw setError(VBOX_E_NOT_SUPPORTED,
    25212521                           tr("Medium format '%s' does not support dynamic storage creation"),
    … …  
    25232523
    25242524        if (    (mediumVariantFlags & MediumVariant_Fixed)
    2525             &&  !(m->formatObj->getCapabilities() & MediumFormatCapabilities_CreateDynamic))
     2525            &&  !(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_CreateDynamic))
    25262526            throw setError(VBOX_E_NOT_SUPPORTED,
    25272527                           tr("Medium format '%s' does not support fixed storage creation"),
    … …  
    31943194{
    31953195    if (    m->formatObj
    3196          && (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
     3196         && (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
    31973197       )
    31983198        return true;
    … …  
    41374137
    41384138    /* check that our own format supports diffs */
    4139     if (!(m->formatObj->getCapabilities() & MediumFormatCapabilities_Differencing))
     4139    if (!(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_Differencing))
    41404140    {
    41414141        /* use the default format if not */
    … …  
    42704270        LogFlowThisFunc(("aWait=%RTbool locationFull=%s\n", aWait, getLocationFull().c_str() ));
    42714271
    4272         if (    !(m->formatObj->getCapabilities() & (   MediumFormatCapabilities_CreateDynamic
     4272        if (    !(m->formatObj->i_getCapabilities() & (   MediumFormatCapabilities_CreateDynamic
    42734273                                                      | MediumFormatCapabilities_CreateFixed)))
    42744274            throw setError(VBOX_E_NOT_SUPPORTED,
    … …  
    56765676            }
    56775677
    5678             if (formatObj->getCapabilities() & MediumFormatCapabilities_Uuid)
     5678            if (formatObj->i_getCapabilities() & MediumFormatCapabilities_Uuid)
    56795679            {
    56805680                /* Modify the UUIDs if necessary. The associated fields are
    … …  
    62046204
    62056205    if (   isImport
    6206         || (   (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
     6206        || (   (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
    62076207            && !m->hostDrive))
    62086208    {
    … …  
    62146214        {
    62156215            /* must be a file (formatObj must be already known) */
    6216             Assert(m->formatObj->getCapabilities() & MediumFormatCapabilities_File);
     6216            Assert(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File);
    62176217
    62186218            if (RTPathFilename(aLocation.c_str()) == NULL)
    … …  
    62226222                 * this */
    62236223
    6224                 ComAssertMsgRet(!m->formatObj->getFileExtensions().empty(),
     6224                ComAssertMsgRet(!m->formatObj->i_getFileExtensions().empty(),
    62256225                                ("Must be at least one extension if it is MediumFormatCapabilities_File\n"),
    62266226                                E_FAIL);
    62276227
    6228                 Utf8Str strExt = m->formatObj->getFileExtensions().front();
     6228                Utf8Str strExt = m->formatObj->i_getFileExtensions().front();
    62296229                ComAssertMsgRet(!strExt.isEmpty(),
    62306230                                ("Default extension must not be empty\n"),
    … …  
    62406240        // we must always have full paths now (if it refers to a file)
    62416241        if (   (   m->formatObj.isNull()
    6242                 || m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
     6242                || m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
    62436243            && !RTPathStartsWithRoot(locationFull.c_str()))
    62446244            return setError(VBOX_E_FILE_ERROR,
    … …  
    63266326
    63276327        /* is it still a file? */
    6328         if (    (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
     6328        if (    (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
    63296329             && (m->state == MediumState_NotCreated)
    63306330           )
    … …  
    63746374        Assert(m->mapProperties.empty());
    63756375
    6376         for (MediumFormat::PropertyList::const_iterator it = m->formatObj->getProperties().begin();
    6377              it != m->formatObj->getProperties().end();
     6376        for (MediumFormat::PropertyArray::const_iterator it = m->formatObj->i_getProperties().begin();
     6377             it != m->formatObj->i_getProperties().end();
    63786378             ++it)
    63796379        {
    … …  
    67646764        Utf8Str format(m->strFormat);
    67656765        Utf8Str location(m->strLocationFull);
    6766         uint64_t capabilities = m->formatObj->getCapabilities();
     6766        uint64_t capabilities = m->formatObj->i_getCapabilities();
    67676767        ComAssertThrow(capabilities & (  MediumFormatCapabilities_CreateFixed
    67686768                                       | MediumFormatCapabilities_CreateDynamic), E_FAIL);
    … …  
    69046904        Utf8Str targetFormat(pTarget->m->strFormat);
    69056905        Utf8Str targetLocation(pTarget->m->strLocationFull);
    6906         uint64_t capabilities = pTarget->m->formatObj->getCapabilities();
     6906        uint64_t capabilities = pTarget->m->formatObj->i_getCapabilities();
    69076907        ComAssertThrow(capabilities & MediumFormatCapabilities_CreateDynamic, E_FAIL);
    69086908
    … …  
    74427442            Utf8Str targetFormat(pTarget->m->strFormat);
    74437443            Utf8Str targetLocation(pTarget->m->strLocationFull);
    7444             uint64_t capabilities = pTarget->m->formatObj->getCapabilities();
     7444            uint64_t capabilities = pTarget->m->formatObj->i_getCapabilities();
    74457445
    74467446            Assert(   pTarget->m->state == MediumState_Creating
    … …  
    81258125            }
    81268126
    8127             Utf8Str targetFormat(task.mFormat->getId());
     8127            Utf8Str targetFormat(task.mFormat->i_getId());
    81288128            Utf8Str targetLocation(task.mFilename);
    8129             uint64_t capabilities = task.mFormat->getCapabilities();
     8129            uint64_t capabilities = task.mFormat->i_getCapabilities();
    81308130
    81318131            Assert(m->state == MediumState_LockedRead);
    … …  
    82388238            /* Open source medium. */
    82398239            vrc = VDOpen(hdd,
    8240                          task.mFormat->getId().c_str(),
     8240                         task.mFormat->i_getId().c_str(),
    82418241                         task.mFilename.c_str(),
    82428242                         VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SEQUENTIAL | m->uOpenFlagsDef,
    … …  
    82508250            Utf8Str targetFormat(m->strFormat);
    82518251            Utf8Str targetLocation(m->strLocationFull);
    8252             uint64_t capabilities = task.mFormat->getCapabilities();
     8252            uint64_t capabilities = task.mFormat->i_getCapabilities();
    82538253
    82548254            Assert(   m->state == MediumState_Creating

  • trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

    r44948 r45491  
    11061106        /* MediumFormat is all const, no need to lock */
    11071107
    1108         if ((*it)->getId().compare(aFormat, Utf8Str::CaseInsensitive) == 0)
     1108        if ((*it)->i_getId().compare(aFormat, Utf8Str::CaseInsensitive) == 0)
    11091109        {
    11101110            format = *it;
    … …  
    11391139    {
    11401140        /* MediumFormat is all const, no need to lock */
    1141         MediumFormat::StrList aFileList = (*it)->getFileExtensions();
    1142         for (MediumFormat::StrList::const_iterator it1 = aFileList.begin();
     1141        MediumFormat::StrArray aFileList = (*it)->i_getFileExtensions();
     1142        for (MediumFormat::StrArray::const_iterator it1 = aFileList.begin();
    11431143             it1 != aFileList.end();
    11441144             ++it1)
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