VirtualBox

Changeset 45497 in vbox for trunk/src


Ignore:
Timestamp:
Apr 11, 2013 8:09:04 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84963
Message:

back out API wrapper generator, too broken with XPCOM

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

Legend:

Unmodified
Added
Removed

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

    r45492 r45497  
    4545# Construct VBOX_MAIN_DEFS
    4646## @todo eliminate or expand VBOX_MAIN_DEFS.
    47 VBOX_MAIN_DEFS   =
     47VBOX_MAIN_DEFS   = 
    4848ifneq ($(KBUILD_TARGET),win)
    4949 ifndef VBOX_WITH_XPCOM
    … …  
    162162docs:                $(PATH_TARGET)/docs.Main
    163163endif
    164 
    165 
    166 #
    167 # Generate library with API class wrappers from the XIDL file.
    168 #
    169 LIBRARIES += VBoxAPIWrap
    170 VBoxAPIWrap_TEMPLATE        = VBOXMAINLIB
    171 VBoxAPIWrap_SOURCES         = $(VBoxAPIWrap_GENERATEDCPP)
    172 VBoxAPIWrap_GENERATEDCPP    = $(filter %.cpp,$(VBoxAPIWrap_GENERATEDSOURCES))
    173 VBoxAPIWrap_GENERATEDSOURCES = $(addprefix $(VBoxAPIWrap_0_OUTDIR)/,$(VBoxAPIWrap_VBOX_APIWRAPPERFILES))
    174 VBoxAPIWrap_RAWSRC          = \
    175         $(VBoxAPIWrap_0_OUTDIR)/apiwrappers
    176 VBoxAPIWrap_XSLT            = \
    177         $(VBOX_PATH_MAIN_SRC)/idl/apiwrap-server.xsl
    178 VBoxAPIWrap_DEFS.win.x86 += _WIN32_WINNT=0x0500
    179 VBoxAPIWrap_DEFS.win.amd64 += _WIN32_WINNT=0x0510
    180 VBoxAPIWrap_INCS           += \
    181         include
    182 VBoxAPIWrap_CLEAN           = \
    183         $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.cpp) \
    184         $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.h) \
    185         $(VBoxAPIWrap_RAWSRC)
    186 VBoxAPIWrap_KMK = $(PATH_OUT)/vboxapiwrap.kmk
    187 include $(VBoxAPIWrap_KMK)
    188164
    189165
    … …  
    284260        $(VBoxSVC_0_OUTDIR) \
    285261        $(dir $(VBOX_XML_SCHEMADEFS_H)) \
    286         $(VBoxAPIWrap_0_OUTDIR) \
    287262        .
    288263VBoxSVC_INCS.win = \
    … …  
    294269
    295270VBoxSVC_LIBS += \
    296         $(PATH_STAGE_LIB)/VBoxAPIWrap$(VBOX_SUFF_LIB) \
    297271        $(PATH_STAGE_LIB)/SSMStandalone$(VBOX_SUFF_LIB) \
    298272        $(LIB_DDU)
    … …  
    573547        include \
    574548        $(VBoxC_0_OUTDIR) \
    575         $(VBoxAPIWrap_0_OUTDIR) \
    576549        $(dir $(VBOX_XML_SCHEMADEFS_H))
    577550VBoxC_INCS.win      = \
    … …  
    893866                | $(VBOX_JMSCOM_GEN)/java/
    894867        $(call MSG_L1,Generating Java MSCOM glue files from XIDL)
    895         $(QUIET)$(RM) -f $(VBOX_JMSCOM_GEN)/java/*.java
     868        $(QUIET)$(RM) -f $(wildcard $(VBOX_JMSCOM_GEN)/java/*.java)
    896869        $(QUIET)$(VBOX_XSLTPROC) \
    897870              --stringparam G_vboxApiSuffix $(VBOX_API_SUFFIX) \
    … …  
    927900        $(VBOX_PATH_MAIN_SRC)/glue/tests/Makefile=>Makefile
    928901
    929 # moved those rules to the end so that VBoxAPIWrap_0_OUTDIR can be expanded without $$ trickery
    930 $(VBoxAPIWrap_RAWSRC) \
    931 +| $(VBoxAPIWrap_GENERATEDSOURCES): \
    932                 $(VBOX_XIDL_FILE) \
    933                 $(VBoxAPIWrap_XSLT) \
    934                 $(VBOX_FILESPLIT) \
    935                 | $$(dir $$@)
    936         $(call MSG_L1,Generating C++ Server API wrapper files from XIDL)
    937         $(QUIET)$(RM) -f $(filter-out $(VBoxAPIWrap_GENERATEDSOURCES),$(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.cpp) $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.h))
    938         $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly "" -o $@ $(VBoxAPIWrap_XSLT) $<
    939         $(QUIET)$(VBOX_FILESPLIT) $@ $(VBoxAPIWrap_0_OUTDIR)
    940 
    941 $(VBoxAPIWrap_KMK).ts +| $(VBoxAPIWrap_KMK): $(VBOX_XIDL_FILE) $(VBoxAPIWrap_XSLT)
    942         $(call MSG_GENERATE,,$(VBoxAPIWrap_KMK))
    943         $(QUIET)$(RM) -f $@
    944         $(QUIET)$(MKDIR) -p $(@D)
    945         $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly VBoxAPIWrap_VBOX_APIWRAPPERFILES -o $@ $(VBoxAPIWrap_XSLT) $<
    946         $(QUIET)$(CP) --changed -fv $@ $(VBoxAPIWrap_KMK)
    947 
    948902updatenls::
    949903        $(VBOX_LUPDATE) $(VBoxSVC_SOURCES) $(VBoxSVC_VBOX_HEADERS) -ts $(VBoxSVC_VBOX_TRANSLATIONS)

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

    r45491 r45497  
    33/** @file
    44 *
    5  * MediumFormat COM class implementation
     5 * VirtualBox COM class implementation
    66 */
    77
    … …  
    1818 */
    1919
    20 #ifndef MEDIUMFORMAT_IMPL_H_
    21 #define MEDIUMFORMAT_IMPL_H_
     20#ifndef ____H_MEDIUMFORMAT
     21#define ____H_MEDIUMFORMAT
    2222
    23 #include "MediumFormatWrap.h"
     23#include "VirtualBoxBase.h"
    2424
     25#include <VBox/com/array.h>
     26
     27#include <list>
    2528
    2629struct VDBACKENDINFO;
    … …  
    3639 */
    3740class ATL_NO_VTABLE MediumFormat :
    38     public MediumFormatWrap
     41    public VirtualBoxBase,
     42    VBOX_SCRIPTABLE_IMPL(IMediumFormat)
    3943{
    4044public:
    … …  
    4953    };
    5054
    51     typedef std::vector<Property> PropertyArray;
    52     typedef std::vector<com::Utf8Str> StrArray;
     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()
    5380
    5481    DECLARE_EMPTY_CTOR_DTOR(MediumFormat)
    … …  
    6188    void uninit();
    6289
     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
    63106    // public methods for internal purposes only
    64107    // (ensure there is a caller and a read lock before calling them!)
    65108
    66109    /** Const, no need to lock */
    67     const Utf8Str &i_getId() const { return m.strId; }
     110    const Utf8Str& getId() const { return m.strId; }
    68111    /** Const, no need to lock */
    69     const StrArray &i_getFileExtensions() const { return m.maFileExtensions; }
     112    const StrList& getFileExtensions() const { return m.llFileExtensions; }
    70113    /** Const, no need to lock */
    71     MediumFormatCapabilities_T i_getCapabilities() const { return m.capabilities; }
     114    MediumFormatCapabilities_T getCapabilities() const { return m.capabilities; }
    72115    /** Const, no need to lock */
    73     const PropertyArray &i_getProperties() const { return m.maProperties; }
     116    const PropertyList& getProperties() const { return m.llProperties; }
    74117
    75118private:
    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     };
    106119
    107120    Data m;
    108121};
    109122
    110 #endif // MEDIUMFORMAT_IMPL_H_
     123#endif // ____H_MEDIUMFORMAT
    111124
    112125/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

    r45491 r45497  
    22/** @file
    33 *
    4  * MediumFormat COM class implementation
     4 * VirtualBox COM class implementation
    55 */
    66
    … …  
    7676            DeviceType_T devType;
    7777
    78             unconst(m.maFileExtensions).push_back(papExtension->pszExtension);
     78            unconst(m.llFileExtensions).push_back(papExtension->pszExtension);
    7979
    8080            switch(papExtension->enmType)
    … …  
    9494            }
    9595
    96             unconst(m.maDeviceTypes).push_back(devType);
     96            unconst(m.llDeviceTypes).push_back(devType);
    9797            ++papExtension;
    9898        }
    … …  
    157157                                    flags,
    158158                                    defaultValue };
    159             unconst(m.maProperties).push_back(prop);
     159            unconst(m.llProperties).push_back(prop);
    160160            ++pa;
    161161        }
    … …  
    181181        return;
    182182
    183     unconst(m.maProperties).clear();
    184     unconst(m.maFileExtensions).clear();
    185     unconst(m.maDeviceTypes).clear();
     183    unconst(m.llProperties).clear();
     184    unconst(m.llFileExtensions).clear();
     185    unconst(m.llDeviceTypes).clear();
    186186    unconst(m.capabilities) = (MediumFormatCapabilities_T)0;
    187187    unconst(m.strName).setNull();
    … …  
    192192/////////////////////////////////////////////////////////////////////////////
    193193
    194 HRESULT MediumFormat::getId(com::Utf8Str &aId)
    195 {
     194STDMETHODIMP MediumFormat::COMGETTER(Id)(BSTR *aId)
     195{
     196    CheckComArgOutPointerValid(aId);
     197
     198    AutoCaller autoCaller(this);
     199    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     200
    196201    /* this is const, no need to lock */
    197     aId = m.strId;
    198 
    199     return S_OK;
    200 }
    201 
    202 HRESULT MediumFormat::getName(com::Utf8Str &aName)
    203 {
     202    m.strId.cloneTo(aId);
     203
     204    return S_OK;
     205}
     206
     207STDMETHODIMP MediumFormat::COMGETTER(Name)(BSTR *aName)
     208{
     209    CheckComArgOutPointerValid(aName);
     210
     211    AutoCaller autoCaller(this);
     212    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     213
    204214    /* this is const, no need to lock */
    205     aName = m.strName;
    206 
    207     return S_OK;
    208 }
    209 
    210 HRESULT 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++)
     215    m.strName.cloneTo(aName);
     216
     217    return S_OK;
     218}
     219
     220STDMETHODIMP 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)
    217232    {
    218         uint64_t tmp = m.capabilities;
    219         tmp &= 1ULL << i;
    220         if (tmp)
    221             aCapabilities[cCapabilities] = (MediumFormatCapabilities_T)tmp;
     233        ULONG temp = m.capabilities;
     234        temp &= 1<<i;
     235        capabilities [i] = (MediumFormatCapabilities_T)temp;
    222236    }
    223     aCapabilities.resize(RT_MIN(cCapabilities, 1));
     237
     238    capabilities.detachTo(ComSafeArrayOutArg(aCaps));
     239
     240    return S_OK;
     241}
     242
     243STDMETHODIMP 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
     271STDMETHODIMP 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));
    224312
    225313    return S_OK;
    … …  
    229317/////////////////////////////////////////////////////////////////////////////
    230318
    231 HRESULT 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 
    241 HRESULT 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 
    267319// public methods only for internal purposes
    268320/////////////////////////////////////////////////////////////////////////////

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

    r45491 r45497  
    959959    if (FAILED(rc)) return rc;
    960960
    961     if (!(m->formatObj->i_getCapabilities() & (   MediumFormatCapabilities_CreateFixed
     961    if (!(m->formatObj->getCapabilities() & (   MediumFormatCapabilities_CreateFixed
    962962                                              | MediumFormatCapabilities_CreateDynamic))
    963963       )
    … …  
    12401240
    12411241    Utf8Str strFull;
    1242     if (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
     1242    if (m->formatObj->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->i_getCapabilities() & MediumFormatCapabilities_CreateDynamic))
     2519            &&  !(m->formatObj->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->i_getCapabilities() & MediumFormatCapabilities_CreateDynamic))
     2525            &&  !(m->formatObj->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->i_getCapabilities() & MediumFormatCapabilities_File)
     3196         && (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
    31973197       )
    31983198        return true;
    … …  
    41374137
    41384138    /* check that our own format supports diffs */
    4139     if (!(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_Differencing))
     4139    if (!(m->formatObj->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->i_getCapabilities() & (   MediumFormatCapabilities_CreateDynamic
     4272        if (    !(m->formatObj->getCapabilities() & (   MediumFormatCapabilities_CreateDynamic
    42734273                                                      | MediumFormatCapabilities_CreateFixed)))
    42744274            throw setError(VBOX_E_NOT_SUPPORTED,
    … …  
    56765676            }
    56775677
    5678             if (formatObj->i_getCapabilities() & MediumFormatCapabilities_Uuid)
     5678            if (formatObj->getCapabilities() & MediumFormatCapabilities_Uuid)
    56795679            {
    56805680                /* Modify the UUIDs if necessary. The associated fields are
    … …  
    62046204
    62056205    if (   isImport
    6206         || (   (m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File)
     6206        || (   (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
    62076207            && !m->hostDrive))
    62086208    {
    … …  
    62146214        {
    62156215            /* must be a file (formatObj must be already known) */
    6216             Assert(m->formatObj->i_getCapabilities() & MediumFormatCapabilities_File);
     6216            Assert(m->formatObj->getCapabilities() & MediumFormatCapabilities_File);
    62176217
    62186218            if (RTPathFilename(aLocation.c_str()) == NULL)
    … …  
    62226222                 * this */
    62236223
    6224                 ComAssertMsgRet(!m->formatObj->i_getFileExtensions().empty(),
     6224                ComAssertMsgRet(!m->formatObj->getFileExtensions().empty(),
    62256225                                ("Must be at least one extension if it is MediumFormatCapabilities_File\n"),
    62266226                                E_FAIL);
    62276227
    6228                 Utf8Str strExt = m->formatObj->i_getFileExtensions().front();
     6228                Utf8Str strExt = m->formatObj->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->i_getCapabilities() & MediumFormatCapabilities_File)
     6242                || m->formatObj->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->i_getCapabilities() & MediumFormatCapabilities_File)
     6328        if (    (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
    63296329             && (m->state == MediumState_NotCreated)
    63306330           )
    … …  
    63746374        Assert(m->mapProperties.empty());
    63756375
    6376         for (MediumFormat::PropertyArray::const_iterator it = m->formatObj->i_getProperties().begin();
    6377              it != m->formatObj->i_getProperties().end();
     6376        for (MediumFormat::PropertyList::const_iterator it = m->formatObj->getProperties().begin();
     6377             it != m->formatObj->getProperties().end();
    63786378             ++it)
    63796379        {
    … …  
    67646764        Utf8Str format(m->strFormat);
    67656765        Utf8Str location(m->strLocationFull);
    6766         uint64_t capabilities = m->formatObj->i_getCapabilities();
     6766        uint64_t capabilities = m->formatObj->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->i_getCapabilities();
     6906        uint64_t capabilities = pTarget->m->formatObj->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->i_getCapabilities();
     7444            uint64_t capabilities = pTarget->m->formatObj->getCapabilities();
    74457445
    74467446            Assert(   pTarget->m->state == MediumState_Creating
    … …  
    81258125            }
    81268126
    8127             Utf8Str targetFormat(task.mFormat->i_getId());
     8127            Utf8Str targetFormat(task.mFormat->getId());
    81288128            Utf8Str targetLocation(task.mFilename);
    8129             uint64_t capabilities = task.mFormat->i_getCapabilities();
     8129            uint64_t capabilities = task.mFormat->getCapabilities();
    81308130
    81318131            Assert(m->state == MediumState_LockedRead);
    … …  
    82388238            /* Open source medium. */
    82398239            vrc = VDOpen(hdd,
    8240                          task.mFormat->i_getId().c_str(),
     8240                         task.mFormat->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->i_getCapabilities();
     8252            uint64_t capabilities = task.mFormat->getCapabilities();
    82538253
    82548254            Assert(   m->state == MediumState_Creating

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

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