VirtualBox

Changeset 45518 in vbox for trunk/src


Ignore:
Timestamp:
Apr 12, 2013 12:01:02 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84995
Message:

Main: Code generator for (xp)com API implementations, including logging and parameter conversion, so far only used by MediumFormat. Next try, needed significant tweaks to work with xpcom (safearray handling fixes in the parameter conversion helpers), different STL implementation (which doesn't support declaring template type parameters as const), missing build dependencies (which didn't show on the dual core system used for writing the code), and finally the duplicate XPCOM classinfo and AddRef/Release/QueryInterface method definitions needed to be removed.

Location:
trunk/src/VBox/Main
Files:
6 edited
2 copied

Legend:

Unmodified
Added
Removed

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

    r45497 r45518  
    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#
     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
     282VBoxSVC_DEPS = $(filter %.h,$(VBoxAPIWrap_GENERATEDSOURCES))
     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)
    … …  
    544572endif
    545573
     574VBoxC_DEPS = $(filter %.h,$(VBoxAPIWrap_GENERATEDSOURCES))
     575
    546576VBoxC_INCS          = \
    547577        include \
    548578        $(VBoxC_0_OUTDIR) \
     579        $(VBoxAPIWrap_0_OUTDIR) \
    549580        $(dir $(VBOX_XML_SCHEMADEFS_H))
    550581VBoxC_INCS.win      = \
    … …  
    900931        $(VBOX_PATH_MAIN_SRC)/glue/tests/Makefile=>Makefile
    901932
     933# moved those rules to the end so that VBoxAPIWrap_0_OUTDIR can be expanded without $$ trickery
     934$(VBoxAPIWrap_RAWSRC) \
     935+| $(VBoxAPIWrap_GENERATEDSOURCES): \
     936                $(VBOX_XIDL_FILE) \
     937                $(VBoxAPIWrap_XSLT) \
     938                $(VBOX_FILESPLIT) \
     939                | $$(dir $$@)
     940        $(call MSG_L1,Generating C++ Server API wrapper files from XIDL)
     941        $(QUIET)$(RM) -f $(filter-out $(VBoxAPIWrap_GENERATEDSOURCES),$(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.cpp) $(wildcard $(VBoxAPIWrap_0_OUTDIR)/*.h))
     942        $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly "" -o $@ $(VBoxAPIWrap_XSLT) $<
     943        $(QUIET)$(VBOX_FILESPLIT) $@ $(VBoxAPIWrap_0_OUTDIR)
     944
     945$(VBoxAPIWrap_KMK).ts +| $(VBoxAPIWrap_KMK): $(VBOX_XIDL_FILE) $(VBoxAPIWrap_XSLT)
     946        $(call MSG_GENERATE,,$(VBoxAPIWrap_KMK))
     947        $(QUIET)$(RM) -f $@
     948        $(QUIET)$(MKDIR) -p $(@D)
     949        $(QUIET)$(VBOX_XSLTPROC) --stringparam filelistonly VBoxAPIWrap_VBOX_APIWRAPPERFILES -o $@ $(VBoxAPIWrap_XSLT) $<
     950        $(QUIET)$(CP) --changed -fv $@ $(VBoxAPIWrap_KMK)
     951
    902952updatenls::
    903953        $(VBOX_LUPDATE) $(VBoxSVC_SOURCES) $(VBoxSVC_VBOX_HEADERS) -ts $(VBoxSVC_VBOX_TRANSLATIONS)

  • trunk/src/VBox/Main/idl/apiwrap-server.xsl

    r45496 r45518  
    218218    <xsl:param name="type"/>
    219219    <xsl:param name="dir"/>
     220    <xsl:param name="safearray"/>
    220221
    221222    <!-- get C++ wrap type from IDL type from table in typemap-shared.inc.xsl -->
    … …  
    223224    <xsl:choose>
    224225        <xsl:when test="$type='wstring'">
    225             <xsl:if test="$dir='in'">
     226            <xsl:if test="$dir='in' and not($safearray='yes')">
    226227                <xsl:text>const </xsl:text>
    227228            </xsl:if>
    … …  
    241242        </xsl:when>
    242243        <xsl:when test="$type='$unknown'">
    243             <xsl:if test="$dir='in'">
     244            <xsl:if test="$dir='in' and not($safearray='yes')">
    244245                <xsl:text>const </xsl:text>
    245246            </xsl:if>
    … …  
    249250            <xsl:variable name="thatif" select="//interface[@name=$type]"/>
    250251            <xsl:variable name="thatifname" select="$thatif/@name"/>
    251             <xsl:if test="$dir='in'">
     252            <xsl:if test="$dir='in' and not($safearray='yes')">
    252253                <xsl:text>const </xsl:text>
    253254            </xsl:if>
    … …  
    351352            <xsl:with-param name="type" select="."/>
    352353            <xsl:with-param name="dir" select="$dir"/>
     354            <xsl:with-param name="safearray" select="../@safearray"/>
    353355        </xsl:call-template>
    354356    </xsl:variable>
    … …  
    476478                </xsl:otherwise>
    477479            </xsl:choose>
     480            <xsl:if test="../@safearray='yes'">
     481                <xsl:choose>
     482                    <xsl:when test="$dir='in'">
     483                        <xsl:text>ComSafeArrayInArg(</xsl:text>
     484                    </xsl:when>
     485                    <xsl:otherwise>
     486                        <xsl:text>ComSafeArrayOutArg(</xsl:text>
     487                    </xsl:otherwise>
     488                </xsl:choose>
     489            </xsl:if>
    478490        </xsl:when>
    479491        <xsl:when test="$thatif">
    … …  
    491503            </xsl:choose>
    492504            <xsl:value-of select="concat('&lt;', $thatifname, '&gt;(')"/>
     505            <xsl:if test="../@safearray='yes'">
     506                <xsl:choose>
     507                    <xsl:when test="$dir='in'">
     508                        <xsl:text>ComSafeArrayInArg(</xsl:text>
     509                    </xsl:when>
     510                    <xsl:otherwise>
     511                        <xsl:text>ComSafeArrayOutArg(</xsl:text>
     512                    </xsl:otherwise>
     513                </xsl:choose>
     514            </xsl:if>
    493515        </xsl:when>
    494516        <xsl:when test="$type='wstring'">
    … …  
    504526                </xsl:otherwise>
    505527            </xsl:choose>
     528            <xsl:if test="../@safearray='yes'">
     529                <xsl:choose>
     530                    <xsl:when test="$dir='in'">
     531                        <xsl:text>ComSafeArrayInArg(</xsl:text>
     532                    </xsl:when>
     533                    <xsl:otherwise>
     534                        <xsl:text>ComSafeArrayOutArg(</xsl:text>
     535                    </xsl:otherwise>
     536                </xsl:choose>
     537            </xsl:if>
    506538        </xsl:when>
    507539        <xsl:when test="$type='uuid'">
    … …  
    517549                </xsl:otherwise>
    518550            </xsl:choose>
     551            <xsl:if test="../@safearray='yes'">
     552                <xsl:choose>
     553                    <xsl:when test="$dir='in'">
     554                        <xsl:text>ComSafeArrayInArg(</xsl:text>
     555                    </xsl:when>
     556                    <xsl:otherwise>
     557                        <xsl:text>ComSafeArrayOutArg(</xsl:text>
     558                    </xsl:otherwise>
     559                </xsl:choose>
     560            </xsl:if>
    519561        </xsl:when>
    520562        <xsl:otherwise>
    … …  
    530572                </xsl:choose>
    531573                <xsl:value-of select="concat('&lt;', $gluetype, '&gt;(')"/>
     574                <xsl:choose>
     575                    <xsl:when test="$dir='in'">
     576                        <xsl:text>ComSafeArrayInArg(</xsl:text>
     577                    </xsl:when>
     578                    <xsl:otherwise>
     579                        <xsl:text>ComSafeArrayOutArg(</xsl:text>
     580                    </xsl:otherwise>
     581                </xsl:choose>
    532582            </xsl:if>
    533583        </xsl:otherwise>
    … …  
    541591            <xsl:choose>
    542592                <xsl:when test="../@safearray='yes'">
    543                     <xsl:text>).array()</xsl:text>
     593                    <xsl:text>)).array()</xsl:text>
    544594                </xsl:when>
    545595                <xsl:otherwise>
    … …  
    551601            <xsl:choose>
    552602                <xsl:when test="../@safearray='yes'">
    553                     <xsl:text>).array()</xsl:text>
     603                    <xsl:text>)).array()</xsl:text>
    554604                </xsl:when>
    555605                <xsl:otherwise>
    … …  
    561611            <xsl:choose>
    562612                <xsl:when test="../@safearray='yes'">
    563                     <xsl:text>).array()</xsl:text>
     613                    <xsl:text>)).array()</xsl:text>
    564614                </xsl:when>
    565615                <xsl:otherwise>
    … …  
    570620        <xsl:otherwise>
    571621            <xsl:if test="../@safearray='yes'">
    572                 <xsl:text>).array()</xsl:text>
     622                <xsl:text>)).array()</xsl:text>
    573623            </xsl:if>
    574624        </xsl:otherwise>

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

    r45497 r45518  
    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/include/Wrapper.h

    r45496 r45518  
    6060        return mStr;
    6161    }
    62    
     62
    6363private:
    6464    com::Utf8Str mStr;
    … …  
    8585        return mSrc;
    8686    }
    87    
     87
    8888private:
    8989    const com::Utf8Str mSrc;
    … …  
    128128        return mArray;
    129129    }
    130    
     130
    131131private:
    132132    std::vector<com::Utf8Str> mArray;
    … …  
    148148    ArrayBSTRInConverter(ComSafeArrayIn(IN_BSTR, aSrc))
    149149    {
    150         com::SafeArray<BSTR> inArray(ComSafeArrayInArg(aSrc));
     150        com::SafeArray<IN_BSTR> inArray(ComSafeArrayInArg(aSrc));
    151151        mArray.resize(inArray.size());
    152152        for (size_t i = 0; i < inArray.size(); i++)
    … …  
    158158    }
    159159
    160     const std::vector<const com::Utf8Str> &array()
    161     {
    162         return mArray;
    163     }
    164    
    165 private:
    166     std::vector<const com::Utf8Str> mArray;
     160    const std::vector<com::Utf8Str> &array()
     161    {
     162        return mArray;
     163    }
     164
     165private:
     166    std::vector<com::Utf8Str> mArray;
    167167};
    168168
    … …  
    188188        return mUuid;
    189189    }
    190    
     190
    191191private:
    192192    com::Guid mUuid;
    … …  
    213213        return mSrc;
    214214    }
    215    
     215
    216216private:
    217217    const com::Guid mSrc;
    … …  
    256256        return mArray;
    257257    }
    258    
     258
    259259private:
    260260    std::vector<com::Guid> mArray;
    … …  
    289289        return mPtr;
    290290    }
    291    
     291
    292292private:
    293293    ComPtr<A> mPtr;
    … …  
    315315        return mSrc;
    316316    }
    317    
     317
    318318private:
    319319    const ComPtr<A> mSrc;
    … …  
    334334    }
    335335
    336     ArrayComTypeOutConverter(ComSafeArrayOut(A, aDst)) :
     336    ArrayComTypeOutConverter(ComSafeArrayOut(A *, aDst)) :
    337337#ifdef VBOX_WITH_XPCOM
    338338        mDstSize(aDstSize),
    … …  
    359359        return mArray;
    360360    }
    361    
     361
    362362private:
    363363    std::vector<ComPtr<A> > mArray;
    364364#ifdef VBOX_WITH_XPCOM
    365365    PRUint32 *mDstSize;
    366     A **mDst;
     366    A ***mDst;
    367367#else // !VBOX_WITH_XPCOM
    368368    SAFEARRAY **mDst;
    … …  
    378378    }
    379379
    380     ArrayComTypeInConverter(ComSafeArrayIn(A, aSrc))
     380    ArrayComTypeInConverter(ComSafeArrayIn(A *, aSrc))
    381381    {
    382382        com::SafeIfaceArray<A> inArray(ComSafeArrayInArg(aSrc));
    … …  
    390390    }
    391391
    392     const std::vector<const ComPtr<A> > &array()
    393     {
    394         return mArray;
    395     }
    396    
    397 private:
    398     std::vector<const ComPtr<A> > mArray;
     392    const std::vector<ComPtr<A> > &array()
     393    {
     394        return mArray;
     395    }
     396
     397private:
     398    std::vector<ComPtr<A> > mArray;
    399399};
    400400
    … …  
    438438        return mArray;
    439439    }
    440    
     440
    441441private:
    442442    std::vector<A> mArray;
    … …  
    473473        return mArray;
    474474    }
    475    
     475
    476476private:
    477477    std::vector<A> mArray;

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

    r45497 r45518  
    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

    r45497 r45518  
    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

    r45497 r45518  
    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)

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

    r45138 r45518  
    128128NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Medium, IMedium)
    129129
    130 NS_DECL_CLASSINFO(MediumFormat)
    131 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumFormat, IMediumFormat)
    132 
    133130NS_DECL_CLASSINFO(MediumAttachment)
    134131NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumAttachment, IMediumAttachment)
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