VirtualBox

Changeset 36186 in vbox for trunk/include/VBox


Ignore:
Timestamp:
Mar 7, 2011 1:14:34 PM (14 years ago)
Author:
vboxsync
Message:

com/array.h: whitespace/ifdef cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/com/array.h

    r35913 r36186  
    55
    66/*
    7  * Copyright (C) 2006-2007 Oracle Corporation
     7 * Copyright (C) 2006-2011 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    5656 * @code
    5757
    58     STDMETHOD(TestArrays) (ComSafeArrayIn (LONG, aIn),
    59                            ComSafeArrayOut (LONG, aOut),
    60                            ComSafeArrayOut (LONG, aRet));
     58    STDMETHOD(TestArrays)(ComSafeArrayIn(LONG, aIn),
     59                          ComSafeArrayOut(LONG, aOut),
     60                          ComSafeArrayOut(LONG, aRet));
    6161
    6262 * @endcode
    … …  
    6565 * @code
    6666
    67     STDMETHODIMP Component::TestArrays (ComSafeArrayIn (LONG, aIn),
    68                                         ComSafeArrayOut (LONG, aOut),
    69                                         ComSafeArrayOut (LONG, aRet))
    70     {
    71         if (ComSafeArrayInIsNull (aIn))
     67    STDMETHODIMP Component::TestArrays(ComSafeArrayIn(LONG, aIn),
     68                                       ComSafeArrayOut(LONG, aOut),
     69                                       ComSafeArrayOut(LONG, aRet))
     70    {
     71        if (ComSafeArrayInIsNull(aIn))
    7272            return E_INVALIDARG;
    73         if (ComSafeArrayOutIsNull (aOut))
     73        if (ComSafeArrayOutIsNull(aOut))
    7474            return E_POINTER;
    75         if (ComSafeArrayOutIsNull (aRet))
     75        if (ComSafeArrayOutIsNull(aRet))
    7676            return E_POINTER;
    7777
    7878        // Use SafeArray to access the input array parameter
    7979
    80         com::SafeArray <LONG> in (ComSafeArrayInArg (aIn));
     80        com::SafeArray<LONG> in(ComSafeArrayInArg(aIn));
    8181
    8282        for (size_t i = 0; i < in.size(); ++ i)
    83             LogFlow (("*** in[%u]=%d\n", i, in [i]));
     83            LogFlow(("*** in[%u]=%d\n", i, in[i]));
    8484
    8585        // Use SafeArray to create the return array (the same technique is used
    8686        // for output array parameters)
    8787
    88         SafeArray <LONG> ret (in.size() * 2);
     88        SafeArray<LONG> ret(in.size() * 2);
    8989        for (size_t i = 0; i < in.size(); ++ i)
    9090        {
    91             ret [i] = in [i];
    92             ret [i + in.size()] = in [i] * 10;
    93         }
    94 
    95         ret.detachTo (ComSafeArrayOutArg (aRet));
     91            ret[i] = in[i];
     92            ret[i + in.size()] = in[i] * 10;
     93        }
     94
     95        ret.detachTo(ComSafeArrayOutArg(aRet));
    9696
    9797        return S_OK;
    … …  
    103103 * @code
    104104
    105     ComPtr <ISomething> component;
     105    ComPtr<ISomething> component;
    106106
    107107    // ...
    108108
    109     com::SafeArray <LONG> in (3);
    110     in [0] = -1;
    111     in [1] = -2;
    112     in [2] = -3;
    113 
    114     com::SafeArray <LONG> out;
    115     com::SafeArray <LONG> ret;
    116 
    117     HRESULT rc = component->TestArrays (ComSafeArrayAsInParam (in),
    118                                         ComSafeArrayAsOutParam (out),
    119                                         ComSafeArrayAsOutParam (ret));
    120 
    121     if (SUCCEEDED (rc))
     109    com::SafeArray<LONG> in(3);
     110    in[0] = -1;
     111    in[1] = -2;
     112    in[2] = -3;
     113
     114    com::SafeArray<LONG> out;
     115    com::SafeArray<LONG> ret;
     116
     117    HRESULT rc = component->TestArrays(ComSafeArrayAsInParam(in),
     118                                       ComSafeArrayAsOutParam(out),
     119                                       ComSafeArrayAsOutParam(ret));
     120
     121    if (SUCCEEDED(rc))
    122122        for (size_t i = 0; i < ret.size(); ++ i)
    123             printf ("*** ret[%u]=%d\n", i, ret [i]);
     123            printf("*** ret[%u]=%d\n", i, ret[i]);
    124124
    125125 * @endcode
    … …  
    130130 * @code
    131131
    132     STDMETHODIMP Component::COMGETTER(Values) (ComSafeArrayOut (int, aValues))
    133     {
    134         // ... assume there is a |std::list <int> mValues| data member
    135 
    136         com::SafeArray <int> values (mValues);
    137         values.detachTo (ComSafeArrayOutArg (aValues));
     132    STDMETHODIMP Component::COMGETTER(Values)(ComSafeArrayOut(int, aValues))
     133    {
     134        // ... assume there is a |std::list<int> mValues| data member
     135
     136        com::SafeArray<int> values(mValues);
     137        values.detachTo(ComSafeArrayOutArg(aValues));
    138138
    139139        return S_OK;
    … …  
    151151 *
    152152 * Also note that in order to pass input BSTR array parameters declared
    153  * using the ComSafeArrayIn (IN_BSTR, aParam) macro to the SafeArray<>
     153 * using the ComSafeArrayIn(IN_BSTR, aParam) macro to the SafeArray<>
    154154 * constructor using the ComSafeArrayInArg() macro, you should use IN_BSTR
    155155 * as the SafeArray<> template argument, not just BSTR.
    … …  
    161161 */
    162162
    163 #if defined (VBOX_WITH_XPCOM)
     163#ifdef VBOX_WITH_XPCOM
    164164# include <nsMemory.h>
    165165#endif
    … …  
    169169#include "VBox/com/assert.h"
    170170
    171 #if defined (VBOX_WITH_XPCOM)
     171#ifdef VBOX_WITH_XPCOM
    172172
    173173/**
    … …  
    179179 */
    180180#define ComSafeArrayAsInParam(aArray)   \
    181     (aArray).size(), (aArray).__asInParam_Arr ((aArray).raw())
     181    (aArray).size(), (aArray).__asInParam_Arr((aArray).raw())
    182182
    183183/**
    … …  
    191191    (aArray).__asOutParam_Size(), (aArray).__asOutParam_Arr()
    192192
    193 #else /* defined (VBOX_WITH_XPCOM) */
     193#else /* !VBOX_WITH_XPCOM */
    194194
    195195#define ComSafeArrayAsInParam(aArray)   (aArray).__asInParam()
    … …  
    197197#define ComSafeArrayAsOutParam(aArray)  (aArray).__asOutParam()
    198198
    199 #endif /* defined (VBOX_WITH_XPCOM) */
     199#endif /* !VBOX_WITH_XPCOM */
    200200
    201201/**
    … …  
    205205{
    206206
    207 #if defined (VBOX_WITH_XPCOM)
     207#ifdef VBOX_WITH_XPCOM
    208208
    209209////////////////////////////////////////////////////////////////////////////////
    … …  
    214214 * @param T Type of array elements.
    215215 */
    216 template <typename T>
     216template<typename T>
    217217struct SafeArrayTraits
    218218{
    … …  
    220220
    221221    /** Initializes memory for aElem. */
    222     static void Init (T &aElem) { aElem = 0; }
     222    static void Init(T &aElem) { aElem = 0; }
    223223
    224224    /** Initializes memory occupied by aElem. */
    225     static void Uninit (T &aElem) { aElem = 0; }
     225    static void Uninit(T &aElem) { aElem = 0; }
    226226
    227227    /** Creates a deep copy of aFrom and stores it in aTo. */
    228     static void Copy (const T &aFrom, T &aTo) { aTo = aFrom; }
     228    static void Copy(const T &aFrom, T &aTo) { aTo = aFrom; }
    229229
    230230public:
    … …  
    235235     * (char/PRUnichar pointers) as const but doesn't do so for pointers to
    236236     * arrays. */
    237     static T *__asInParam_Arr (T *aArr) { return aArr; }
    238     static T *__asInParam_Arr (const T *aArr) { return const_cast <T *> (aArr); }
    239 };
    240 
    241 template <typename T>
    242 struct SafeArrayTraits <T *>
     237    static T *__asInParam_Arr(T *aArr) { return aArr; }
     238    static T *__asInParam_Arr(const T *aArr) { return const_cast<T *>(aArr); }
     239};
     240
     241template<typename T>
     242struct SafeArrayTraits<T *>
    243243{
    244244    // Arbitrary pointers are not supported
    … …  
    246246
    247247template<>
    248 struct SafeArrayTraits <PRUnichar *>
     248struct SafeArrayTraits<PRUnichar *>
    249249{
    250250protected:
    251251
    252     static void Init (PRUnichar * &aElem) { aElem = NULL; }
    253 
    254     static void Uninit (PRUnichar * &aElem)
     252    static void Init(PRUnichar * &aElem) { aElem = NULL; }
     253
     254    static void Uninit(PRUnichar * &aElem)
    255255    {
    256256        if (aElem)
    257257        {
    258             ::SysFreeString (aElem);
     258            ::SysFreeString(aElem);
    259259            aElem = NULL;
    260260        }
    261261    }
    262262
    263     static void Copy (const PRUnichar * aFrom, PRUnichar * &aTo)
    264     {
    265         AssertCompile (sizeof (PRUnichar) == sizeof (OLECHAR));
    266         aTo = aFrom ? ::SysAllocString ((const OLECHAR *) aFrom) : NULL;
     263    static void Copy(const PRUnichar * aFrom, PRUnichar * &aTo)
     264    {
     265        AssertCompile(sizeof(PRUnichar) == sizeof(OLECHAR));
     266        aTo = aFrom ? ::SysAllocString((const OLECHAR *)aFrom) : NULL;
    267267    }
    268268
    … …  
    270270
    271271    /* Magic to workaround strict rules of par. 4.4.4 of the C++ standard */
    272     static const PRUnichar **__asInParam_Arr (PRUnichar **aArr)
    273     {
    274         return const_cast <const PRUnichar **> (aArr);
    275     }
    276     static const PRUnichar **__asInParam_Arr (const PRUnichar **aArr) { return aArr; }
     272    static const PRUnichar **__asInParam_Arr(PRUnichar **aArr)
     273    {
     274        return const_cast<const PRUnichar **>(aArr);
     275    }
     276    static const PRUnichar **__asInParam_Arr(const PRUnichar **aArr) { return aArr; }
    277277};
    278278
    279279template<>
    280 struct SafeArrayTraits <const PRUnichar *>
     280struct SafeArrayTraits<const PRUnichar *>
    281281{
    282282protected:
    283283
    284     static void Init (const PRUnichar * &aElem) { aElem = NULL; }
    285     static void Uninit (const PRUnichar * &aElem)
     284    static void Init(const PRUnichar * &aElem) { aElem = NULL; }
     285    static void Uninit(const PRUnichar * &aElem)
    286286    {
    287287        if (aElem)
    288288        {
    289             ::SysFreeString (const_cast <PRUnichar *> (aElem));
     289            ::SysFreeString(const_cast<PRUnichar *>(aElem));
    290290            aElem = NULL;
    291291        }
    292292    }
    293293
    294     static void Copy (const PRUnichar * aFrom, const PRUnichar * &aTo)
    295     {
    296         AssertCompile (sizeof (PRUnichar) == sizeof (OLECHAR));
    297         aTo = aFrom ? ::SysAllocString ((const OLECHAR *) aFrom) : NULL;
     294    static void Copy(const PRUnichar * aFrom, const PRUnichar * &aTo)
     295    {
     296        AssertCompile(sizeof(PRUnichar) == sizeof(OLECHAR));
     297        aTo = aFrom ? ::SysAllocString((const OLECHAR *)aFrom) : NULL;
    298298    }
    299299
    … …  
    301301
    302302    /* Magic to workaround strict rules of par. 4.4.4 of the C++ standard */
    303     static const PRUnichar **__asInParam_Arr (const PRUnichar **aArr) { return aArr; }
     303    static const PRUnichar **__asInParam_Arr(const PRUnichar **aArr) { return aArr; }
    304304};
    305305
    306306template<>
    307 struct SafeArrayTraits <nsID *>
     307struct SafeArrayTraits<nsID *>
    308308{
    309309protected:
    310310
    311     static void Init (nsID * &aElem) { aElem = NULL; }
    312 
    313     static void Uninit (nsID * &aElem)
     311    static void Init(nsID * &aElem) { aElem = NULL; }
     312
     313    static void Uninit(nsID * &aElem)
    314314    {
    315315        if (aElem)
    316316        {
    317             ::nsMemory::Free (aElem);
     317            ::nsMemory::Free(aElem);
    318318            aElem = NULL;
    319319        }
    320320    }
    321321
    322     static void Copy (const nsID * aFrom, nsID * &aTo)
     322    static void Copy(const nsID * aFrom, nsID * &aTo)
    323323    {
    324324        if (aFrom)
    325325        {
    326             aTo = (nsID *) ::nsMemory::Alloc (sizeof (nsID));
     326            aTo = (nsID *) ::nsMemory::Alloc(sizeof(nsID));
    327327            if (aTo)
    328328                *aTo = *aFrom;
    … …  
    336336     * be never called in context of SafeConstGUIDArray. */
    337337
    338     static void Init (const nsID * &aElem) { NOREF (aElem); AssertFailed(); }
    339     static void Uninit (const nsID * &aElem) { NOREF (aElem); AssertFailed(); }
     338    static void Init(const nsID * &aElem) { NOREF(aElem); AssertFailed(); }
     339    static void Uninit(const nsID * &aElem) { NOREF(aElem); AssertFailed(); }
    340340
    341341public:
    342342
    343343    /** Magic to workaround strict rules of par. 4.4.4 of the C++ standard. */
    344     static const nsID **__asInParam_Arr (nsID **aArr)
    345     {
    346         return const_cast <const nsID **> (aArr);
    347     }
    348     static const nsID **__asInParam_Arr (const nsID **aArr) { return aArr; }
    349 };
    350 
    351 #else /* defined (VBOX_WITH_XPCOM) */
     344    static const nsID **__asInParam_Arr(nsID **aArr)
     345    {
     346        return const_cast<const nsID **>(aArr);
     347    }
     348    static const nsID **__asInParam_Arr(const nsID **aArr) { return aArr; }
     349};
     350
     351#else /* !VBOX_WITH_XPCOM */
    352352
    353353////////////////////////////////////////////////////////////////////////////////
    … …  
    357357protected:
    358358
    359     static SAFEARRAY *CreateSafeArray (VARTYPE aVarType, SAFEARRAYBOUND *aBound)
    360     { return SafeArrayCreate (aVarType, 1, aBound); }
     359    static SAFEARRAY *CreateSafeArray(VARTYPE aVarType, SAFEARRAYBOUND *aBound)
     360    { return SafeArrayCreate(aVarType, 1, aBound); }
    361361};
    362362
    … …  
    373373    // Returns the number of VarType() elements necessary for aSize
    374374    // elements of T
    375     static ULONG VarCount (size_t aSize);
     375    static ULONG VarCount(size_t aSize);
    376376
    377377    // Returns the number of elements of T that fit into the given number of
    378     // VarType() elements (opposite to VarCount (size_t aSize)).
    379     static size_t Size (ULONG aVarCount);
     378    // VarType() elements (opposite to VarCount(size_t aSize)).
     379    static size_t Size(ULONG aVarCount);
    380380
    381381    // Creates a deep copy of aFrom and stores it in aTo
    382     static void Copy (ULONG aFrom, ULONG &aTo);
     382    static void Copy(ULONG aFrom, ULONG &aTo);
    383383 */
    384 template <typename T>
     384template<typename T>
    385385struct SafeArrayTraits : public SafeArrayTraitsBase
    386386{
    … …  
    394394    static VARTYPE VarType()
    395395    {
    396         if (sizeof (T) % 8 == 0) return VT_I8;
    397         if (sizeof (T) % 4 == 0) return VT_I4;
    398         if (sizeof (T) % 2 == 0) return VT_I2;
     396        if (sizeof(T) % 8 == 0) return VT_I8;
     397        if (sizeof(T) % 4 == 0) return VT_I4;
     398        if (sizeof(T) % 2 == 0) return VT_I2;
    399399        return VT_I1;
    400400    }
    401401
    402     static ULONG VarCount (size_t aSize)
    403     {
    404         if (sizeof (T) % 8 == 0) return (ULONG) ((sizeof (T) / 8) * aSize);
    405         if (sizeof (T) % 4 == 0) return (ULONG) ((sizeof (T) / 4) * aSize);
    406         if (sizeof (T) % 2 == 0) return (ULONG) ((sizeof (T) / 2) * aSize);
    407         return (ULONG) (sizeof (T) * aSize);
    408     }
    409 
    410     static size_t Size (ULONG aVarCount)
    411     {
    412         if (sizeof (T) % 8 == 0) return (size_t) (aVarCount * 8) / sizeof (T);
    413         if (sizeof (T) % 4 == 0) return (size_t) (aVarCount * 4) / sizeof (T);
    414         if (sizeof (T) % 2 == 0) return (size_t) (aVarCount * 2) / sizeof (T);
    415         return (size_t) aVarCount / sizeof (T);
    416     }
    417 
    418     static void Copy (T aFrom, T &aTo) { aTo = aFrom; }
    419 };
    420 
    421 template <typename T>
    422 struct SafeArrayTraits <T *>
     402    static ULONG VarCount(size_t aSize)
     403    {
     404        if (sizeof(T) % 8 == 0) return (ULONG)((sizeof(T) / 8) * aSize);
     405        if (sizeof(T) % 4 == 0) return (ULONG)((sizeof(T) / 4) * aSize);
     406        if (sizeof(T) % 2 == 0) return (ULONG)((sizeof(T) / 2) * aSize);
     407        return (ULONG)(sizeof(T) * aSize);
     408    }
     409
     410    static size_t Size(ULONG aVarCount)
     411    {
     412        if (sizeof(T) % 8 == 0) return (size_t)(aVarCount * 8) / sizeof(T);
     413        if (sizeof(T) % 4 == 0) return (size_t)(aVarCount * 4) / sizeof(T);
     414        if (sizeof(T) % 2 == 0) return (size_t)(aVarCount * 2) / sizeof(T);
     415        return (size_t) aVarCount / sizeof(T);
     416    }
     417
     418    static void Copy(T aFrom, T &aTo) { aTo = aFrom; }
     419};
     420
     421template<typename T>
     422struct SafeArrayTraits<T *>
    423423{
    424424    // Arbitrary pointer types are not supported
    … …  
    429429
    430430template<>
    431 struct SafeArrayTraits <LONG> : public SafeArrayTraitsBase
     431struct SafeArrayTraits<LONG> : public SafeArrayTraitsBase
    432432{
    433433protected:
    434434
    435435    static VARTYPE VarType() { return VT_I4; }
    436     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    437     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    438 
    439     static void Copy (LONG aFrom, LONG &aTo) { aTo = aFrom; }
     436    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     437    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     438
     439    static void Copy(LONG aFrom, LONG &aTo) { aTo = aFrom; }
    440440};
    441441
    442442template<>
    443 struct SafeArrayTraits <ULONG> : public SafeArrayTraitsBase
     443struct SafeArrayTraits<ULONG> : public SafeArrayTraitsBase
    444444{
    445445protected:
    446446
    447447    static VARTYPE VarType() { return VT_UI4; }
    448     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    449     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    450 
    451     static void Copy (ULONG aFrom, ULONG &aTo) { aTo = aFrom; }
     448    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     449    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     450
     451    static void Copy(ULONG aFrom, ULONG &aTo) { aTo = aFrom; }
    452452};
    453453
    454454template<>
    455 struct SafeArrayTraits <LONG64> : public SafeArrayTraitsBase
     455struct SafeArrayTraits<LONG64> : public SafeArrayTraitsBase
    456456{
    457457protected:
    458458
    459459    static VARTYPE VarType() { return VT_I8; }
    460     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    461     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    462 
    463     static void Copy (LONG64 aFrom, LONG64 &aTo) { aTo = aFrom; }
     460    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     461    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     462
     463    static void Copy(LONG64 aFrom, LONG64 &aTo) { aTo = aFrom; }
    464464};
    465465
    466466template<>
    467 struct SafeArrayTraits <ULONG64> : public SafeArrayTraitsBase
     467struct SafeArrayTraits<ULONG64> : public SafeArrayTraitsBase
    468468{
    469469protected:
    470470
    471471    static VARTYPE VarType() { return VT_UI8; }
    472     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    473     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    474 
    475     static void Copy (ULONG64 aFrom, ULONG64 &aTo) { aTo = aFrom; }
     472    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     473    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     474
     475    static void Copy(ULONG64 aFrom, ULONG64 &aTo) { aTo = aFrom; }
    476476};
    477477
    478478template<>
    479 struct SafeArrayTraits <BSTR> : public SafeArrayTraitsBase
     479struct SafeArrayTraits<BSTR> : public SafeArrayTraitsBase
    480480{
    481481protected:
    482482
    483483    static VARTYPE VarType() { return VT_BSTR; }
    484     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    485     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    486 
    487     static void Copy (BSTR aFrom, BSTR &aTo)
    488     {
    489         aTo = aFrom ? ::SysAllocString ((const OLECHAR *) aFrom) : NULL;
     484    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     485    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     486
     487    static void Copy(BSTR aFrom, BSTR &aTo)
     488    {
     489        aTo = aFrom ? ::SysAllocString((const OLECHAR *)aFrom) : NULL;
    490490    }
    491491};
    492492
    493493template<>
    494 struct SafeArrayTraits <GUID> : public SafeArrayTraitsBase
     494struct SafeArrayTraits<GUID> : public SafeArrayTraitsBase
    495495{
    496496protected:
    … …  
    500500
    501501    /* GUID is 128 bit, so we need two VT_UI8 */
    502     static ULONG VarCount (size_t aSize)
    503     {
    504         AssertCompileSize (GUID, 16);
    505         return (ULONG) (aSize * 2);
    506     }
    507 
    508     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount / 2; }
    509 
    510     static void Copy (GUID aFrom, GUID &aTo) { aTo = aFrom; }
     502    static ULONG VarCount(size_t aSize)
     503    {
     504        AssertCompileSize(GUID, 16);
     505        return (ULONG)(aSize * 2);
     506    }
     507
     508    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount / 2; }
     509
     510    static void Copy(GUID aFrom, GUID &aTo) { aTo = aFrom; }
    511511};
    512512
    … …  
    517517class OutSafeArrayDipper
    518518{
    519     OutSafeArrayDipper (SAFEARRAY **aArr, void **aRaw)
    520         : arr (aArr), raw (aRaw) { Assert (*aArr == NULL && *aRaw == NULL); }
     519    OutSafeArrayDipper(SAFEARRAY **aArr, void **aRaw)
     520        : arr(aArr), raw(aRaw) { Assert(*aArr == NULL && *aRaw == NULL); }
    521521
    522522    SAFEARRAY **arr;
    523523    void **raw;
    524524
    525     template <class, class> friend class SafeArray;
     525    template<class, class> friend class SafeArray;
    526526
    527527public:
    … …  
    531531        if (*arr != NULL)
    532532        {
    533             HRESULT rc = SafeArrayAccessData (*arr, raw);
    534             AssertComRC (rc);
     533            HRESULT rc = SafeArrayAccessData(*arr, raw);
     534            AssertComRC(rc);
    535535        }
    536536    }
    … …  
    539539};
    540540
    541 #endif /* defined (VBOX_WITH_XPCOM) */
     541#endif /* !VBOX_WITH_XPCOM */
    542542
    543543////////////////////////////////////////////////////////////////////////////////
    … …  
    569569 * @note This class is not thread-safe.
    570570 */
    571 template  <typename T, class Traits = SafeArrayTraits <T> >
     571template<typename T, class Traits = SafeArrayTraits<T> >
    572572class SafeArray : public Traits
    573573{
    … …  
    589589     *       The constructor will also assert in this case.
    590590     */
    591     SafeArray (size_t aSize) { resize (aSize); }
     591    SafeArray(size_t aSize) { resize(aSize); }
    592592
    593593    /**
    … …  
    597597     * this:
    598598     * <pre>
    599      *  SafeArray safeArray (ComSafeArrayInArg (aArg));
     599     *  SafeArray safeArray(ComSafeArrayInArg(aArg));
    600600     * </pre>
    601601     *
    … …  
    606606     * @param aArg  Input method parameter to attach to.
    607607     */
    608     SafeArray (ComSafeArrayIn (T, aArg))
    609     {
    610 #if defined (VBOX_WITH_XPCOM)
    611 
    612         AssertReturnVoid (aArg != NULL);
     608    SafeArray(ComSafeArrayIn(T, aArg))
     609    {
     610#ifdef VBOX_WITH_XPCOM
     611
     612        AssertReturnVoid(aArg != NULL);
    613613
    614614        m.size = aArgSize;
    … …  
    616616        m.isWeak = true;
    617617
    618 #else /* defined (VBOX_WITH_XPCOM) */
    619 
    620         AssertReturnVoid (aArg != NULL);
     618#else /* !VBOX_WITH_XPCOM */
     619
     620        AssertReturnVoid(aArg != NULL);
    621621        SAFEARRAY *arg = aArg;
    622622
    623623        if (arg)
    624624        {
    625             AssertReturnVoid (arg->cDims == 1);
     625            AssertReturnVoid(arg->cDims == 1);
    626626
    627627            VARTYPE vt;
    628             HRESULT rc = SafeArrayGetVartype (arg, &vt);
    629             AssertComRCReturnVoid (rc);
    630             AssertMsgReturnVoid (vt == VarType(),
    631                                  ("Expected vartype %d, got %d.\n",
    632                                   VarType(), vt));
    633 
    634             rc = SafeArrayAccessData (arg, (void HUGEP **) &m.raw);
    635             AssertComRCReturnVoid (rc);
     628            HRESULT rc = SafeArrayGetVartype(arg, &vt);
     629            AssertComRCReturnVoid(rc);
     630            AssertMsgReturnVoid(vt == VarType(),
     631                                ("Expected vartype %d, got %d.\n",
     632                                 VarType(), vt));
     633
     634            rc = SafeArrayAccessData(arg, (void HUGEP **)&m.raw);
     635            AssertComRCReturnVoid(rc);
    636636        }
    637637
    … …  
    639639        m.isWeak = true;
    640640
    641 #endif /* defined (VBOX_WITH_XPCOM) */
     641#endif /* !VBOX_WITH_XPCOM */
    642642    }
    643643
    … …  
    651651     *              @c aCntr).
    652652     */
    653     template <template <typename, typename> class C, class A>
    654     SafeArray (const C <T, A> & aCntr)
    655     {
    656         resize (aCntr.size());
    657         AssertReturnVoid (!isNull());
     653    template<template<typename, typename> class C, class A>
     654    SafeArray(const C<T, A> & aCntr)
     655    {
     656        resize(aCntr.size());
     657        AssertReturnVoid(!isNull());
    658658
    659659        size_t i = 0;
    660         for (typename C <T, A>::const_iterator it = aCntr.begin();
     660        for (typename C<T, A>::const_iterator it = aCntr.begin();
    661661             it != aCntr.end(); ++ it, ++ i)
    662 #if defined (VBOX_WITH_XPCOM)
    663             Copy (*it, m.arr [i]);
    664 #else
    665             Copy (*it, m.raw [i]);
     662#ifdef VBOX_WITH_XPCOM
     663            Copy(*it, m.arr[i]);
     664#else
     665            Copy(*it, m.raw[i]);
    666666#endif
    667667    }
    … …  
    679679     * @param K     Map key class (deduced from @c aCntr).
    680680     */
    681     template <template <typename, typename, typename, typename>
     681    template<template<typename, typename, typename, typename>
    682682              class C, class L, class A, class K>
    683     SafeArray (const C <K, T, L, A> & aMap)
    684     {
    685         typedef C <K, T, L, A> Map;
    686 
    687         resize (aMap.size());
    688         AssertReturnVoid (!isNull());
     683    SafeArray(const C<K, T, L, A> & aMap)
     684    {
     685        typedef C<K, T, L, A> Map;
     686
     687        resize(aMap.size());
     688        AssertReturnVoid(!isNull());
    689689
    690690        int i = 0;
    691691        for (typename Map::const_iterator it = aMap.begin();
    692692             it != aMap.end(); ++ it, ++ i)
    693 #if defined (VBOX_WITH_XPCOM)
    694             Copy (it->second, m.arr [i]);
    695 #else
    696             Copy (it->second, m.raw [i]);
     693#ifdef VBOX_WITH_XPCOM
     694            Copy(it->second, m.arr[i]);
     695#else
     696            Copy(it->second, m.raw[i]);
    697697#endif
    698698    }
    … …  
    734734    size_t size() const
    735735    {
    736 #if defined (VBOX_WITH_XPCOM)
     736#ifdef VBOX_WITH_XPCOM
    737737        if (m.arr)
    738738            return m.size;
    … …  
    740740#else
    741741        if (m.arr)
    742             return Size (m.arr->rgsabound [0].cElements);
     742            return Size(m.arr->rgsabound[0].cElements);
    743743        return 0;
    744744#endif
    … …  
    753753     * This method is handy in cases where you want to assign a copy of the
    754754     * existing value to the array element, for example:
    755      * <tt>Bstr string; array.push_back (string);</tt>. If you create a string
     755     * <tt>Bstr string; array.push_back(string);</tt>. If you create a string
    756756     * just to put it in the array, you may find #appendedRaw() more useful.
    757757     *
    … …  
    761761     *                  memory for resizing.
    762762     */
    763     bool push_back (const T &aElement)
    764     {
    765         if (!ensureCapacity (size() + 1))
     763    bool push_back(const T &aElement)
     764    {
     765        if (!ensureCapacity(size() + 1))
    766766            return false;
    767767
    768 #if defined (VBOX_WITH_XPCOM)
    769         Copy (aElement, m.arr [m.size]);
     768#ifdef VBOX_WITH_XPCOM
     769        Copy(aElement, m.arr[m.size]);
    770770        ++ m.size;
    771771#else
    772         Copy (aElement, m.raw [size() - 1]);
     772        Copy(aElement, m.raw[size() - 1]);
    773773#endif
    774774        return true;
    … …  
    788788     *
    789789     * This method is handy for operations like
    790      * <tt>Bstr ("foo").detachTo (array.appendedRaw());</tt>. Don't use it as
    791      * an l-value (<tt>array.appendedRaw() = SysAllocString (L"tralala");</tt>)
     790     * <tt>Bstr("foo").detachTo(array.appendedRaw());</tt>. Don't use it as
     791     * an l-value (<tt>array.appendedRaw() = SysAllocString(L"tralala");</tt>)
    792792     * since this doesn't check for a NULL condition; use #resize() and
    793793     * #setRawAt() instead. If you need to assign a copy of the existing value
    … …  
    798798    T *appendedRaw()
    799799    {
    800         if (!ensureCapacity (size() + 1))
     800        if (!ensureCapacity(size() + 1))
    801801            return NULL;
    802802
    803 #if defined (VBOX_WITH_XPCOM)
    804         Init (m.arr [m.size]);
     803#ifdef VBOX_WITH_XPCOM
     804        Init(m.arr[m.size]);
    805805        ++ m.size;
    806         return &m.arr [m.size - 1];
     806        return &m.arr[m.size - 1];
    807807#else
    808808        /* nothing to do here, SafeArrayCreate() has performed element
    809809         * initialization */
    810         return &m.raw [size() - 1];
     810        return &m.raw[size() - 1];
    811811#endif
    812812    }
    … …  
    822822     *                  memory for resizing.
    823823     */
    824     bool resize (size_t aNewSize)
    825     {
    826         if (!ensureCapacity (aNewSize))
     824    bool resize(size_t aNewSize)
     825    {
     826        if (!ensureCapacity(aNewSize))
    827827            return false;
    828828
    829 #if defined (VBOX_WITH_XPCOM)
     829#ifdef VBOX_WITH_XPCOM
    830830
    831831        if (m.size < aNewSize)
    … …  
    833833            /* initialize the new elements */
    834834            for (size_t i = m.size; i < aNewSize; ++ i)
    835                 Init (m.arr [i]);
     835                Init(m.arr[i]);
    836836        }
    837837
    … …  
    852852     *                  memory for resizing.
    853853     */
    854     bool reset (size_t aNewSize)
     854    bool reset(size_t aNewSize)
    855855    {
    856856        m.uninit();
    857         return resize (aNewSize);
     857        return resize(aNewSize);
    858858    }
    859859
    … …  
    867867    T *raw()
    868868    {
    869 #if defined (VBOX_WITH_XPCOM)
     869#ifdef VBOX_WITH_XPCOM
    870870        return m.arr;
    871871#else
    … …  
    879879    const T *raw() const
    880880    {
    881 #if defined (VBOX_WITH_XPCOM)
     881#ifdef VBOX_WITH_XPCOM
    882882        return m.arr;
    883883#else
    … …  
    897897    T &operator[] (size_t aIdx)
    898898    {
    899         AssertReturn (m.arr != NULL,  *((T *) NULL));
    900         AssertReturn (aIdx < size(), *((T *) NULL));
    901 #if defined (VBOX_WITH_XPCOM)
    902         return m.arr [aIdx];
    903 #else
    904         AssertReturn (m.raw != NULL,  *((T *) NULL));
    905         return m.raw [aIdx];
     899        AssertReturn(m.arr != NULL,  *((T *)NULL));
     900        AssertReturn(aIdx < size(), *((T *)NULL));
     901#ifdef VBOX_WITH_XPCOM
     902        return m.arr[aIdx];
     903#else
     904        AssertReturn(m.raw != NULL,  *((T *)NULL));
     905        return m.raw[aIdx];
    906906#endif
    907907    }
    … …  
    912912    const T operator[] (size_t aIdx) const
    913913    {
    914         AssertReturn (m.arr != NULL,  *((T *) NULL));
    915         AssertReturn (aIdx < size(), *((T *) NULL));
    916 #if defined (VBOX_WITH_XPCOM)
    917         return m.arr [aIdx];
    918 #else
    919         AssertReturn (m.raw != NULL,  *((T *) NULL));
    920         return m.raw [aIdx];
     914        AssertReturn(m.arr != NULL,  *((T *)NULL));
     915        AssertReturn(aIdx < size(), *((T *)NULL));
     916#ifdef VBOX_WITH_XPCOM
     917        return m.arr[aIdx];
     918#else
     919        AssertReturn(m.raw != NULL,  *((T *)NULL));
     920        return m.raw[aIdx];
    921921#endif
    922922    }
    … …  
    927927     * parameter name in the ComSafeArrayOutArg macro call like this:
    928928     * <pre>
    929      *  safeArray.cloneTo (ComSafeArrayOutArg (aArg));
     929     *  safeArray.cloneTo(ComSafeArrayOutArg(aArg));
    930930     * </pre>
    931931     *
    … …  
    936936     * @param aArg  Output method parameter to clone to.
    937937     */
    938     virtual const SafeArray &cloneTo (ComSafeArrayOut (T, aArg)) const
     938    virtual const SafeArray &cloneTo(ComSafeArrayOut(T, aArg)) const
    939939    {
    940940        /// @todo Implement me!
    941 #if defined (VBOX_WITH_XPCOM)
    942         NOREF (aArgSize);
    943         NOREF (aArg);
    944 #else
    945         NOREF (aArg);
    946 #endif
    947         AssertFailedReturn (*this);
    948     }
    949 
    950     void cloneTo (SafeArray<T>& aOther) const
     941#ifdef VBOX_WITH_XPCOM
     942        NOREF(aArgSize);
     943        NOREF(aArg);
     944#else
     945        NOREF(aArg);
     946#endif
     947        AssertFailedReturn(*this);
     948    }
     949
     950    void cloneTo(SafeArray<T>& aOther) const
    951951    {
    952952        aOther.reset(size());
    … …  
    961961     * ComSafeArrayOutArg macro call like this:
    962962     * <pre>
    963      *  safeArray.detachTo (ComSafeArrayOutArg (aArg));
     963     *  safeArray.detachTo(ComSafeArrayOutArg(aArg));
    964964     * </pre>
    965965     *
    … …  
    973973     * @param aArg  Location to detach to.
    974974     */
    975     virtual SafeArray &detachTo (ComSafeArrayOut (T, aArg))
    976     {
    977         AssertReturn (m.isWeak == false, *this);
    978 
    979 #if defined (VBOX_WITH_XPCOM)
    980 
    981         AssertReturn (aArgSize != NULL, *this);
    982         AssertReturn (aArg != NULL, *this);
     975    virtual SafeArray &detachTo(ComSafeArrayOut(T, aArg))
     976    {
     977        AssertReturn(m.isWeak == false, *this);
     978
     979#ifdef VBOX_WITH_XPCOM
     980
     981        AssertReturn(aArgSize != NULL, *this);
     982        AssertReturn(aArg != NULL, *this);
    983983
    984984        *aArgSize = m.size;
    … …  
    989989        m.arr = NULL;
    990990
    991 #else /* defined (VBOX_WITH_XPCOM) */
    992 
    993         AssertReturn (aArg != NULL, *this);
     991#else /* !VBOX_WITH_XPCOM */
     992
     993        AssertReturn(aArg != NULL, *this);
    994994        *aArg = m.arr;
    995995
    996996        if (m.raw)
    997997        {
    998             HRESULT rc = SafeArrayUnaccessData (m.arr);
    999             AssertComRCReturn (rc, *this);
     998            HRESULT rc = SafeArrayUnaccessData(m.arr);
     999            AssertComRCReturn(rc, *this);
    10001000            m.raw = NULL;
    10011001        }
    … …  
    10041004        m.arr = NULL;
    10051005
    1006 #endif /* defined (VBOX_WITH_XPCOM) */
     1006#endif /* !VBOX_WITH_XPCOM */
    10071007
    10081008        return *this;
    … …  
    10141014    // Public methods for internal purposes only.
    10151015
    1016 #if defined (VBOX_WITH_XPCOM)
     1016#ifdef VBOX_WITH_XPCOM
    10171017
    10181018    /** Internal function. Never call it directly. */
    … …  
    10201020
    10211021    /** Internal function Never call it directly. */
    1022     T **__asOutParam_Arr() { Assert (isNull()); return &m.arr; }
    1023 
    1024 #else /* defined (VBOX_WITH_XPCOM) */
     1022    T **__asOutParam_Arr() { Assert(isNull()); return &m.arr; }
     1023
     1024#else /* !VBOX_WITH_XPCOM */
    10251025
    10261026    /** Internal function Never call it directly. */
    … …  
    10291029    /** Internal function Never call it directly. */
    10301030    OutSafeArrayDipper __asOutParam()
    1031     { setNull(); return OutSafeArrayDipper (&m.arr, (void **) &m.raw); }
    1032 
    1033 #endif /* defined (VBOX_WITH_XPCOM) */
     1031    { setNull(); return OutSafeArrayDipper(&m.arr, (void **)&m.raw); }
     1032
     1033#endif /* !VBOX_WITH_XPCOM */
    10341034
    10351035    static const SafeArray Null;
    … …  
    10581058     * @return @c true on success and @c false if not enough memory.
    10591059     */
    1060     bool ensureCapacity (size_t aNewSize)
    1061     {
    1062         AssertReturn (!m.isWeak, false);
    1063 
    1064 #if defined (VBOX_WITH_XPCOM)
     1060    bool ensureCapacity(size_t aNewSize)
     1061    {
     1062        AssertReturn(!m.isWeak, false);
     1063
     1064#ifdef VBOX_WITH_XPCOM
    10651065
    10661066        /* Note: we distinguish between a null array and an empty (zero
    … …  
    10721072
    10731073        /* Allocate in 16-byte pieces. */
    1074         size_t newCapacity = RT_MAX ((aNewSize + 15) / 16 * 16, 16);
     1074        size_t newCapacity = RT_MAX((aNewSize + 15) / 16 * 16, 16);
    10751075
    10761076        if (m.capacity != newCapacity)
    10771077        {
    1078             T *newArr = (T *) nsMemory::Alloc (RT_MAX (newCapacity, 1) * sizeof (T));
    1079             AssertReturn (newArr != NULL, false);
     1078            T *newArr = (T *)nsMemory::Alloc(RT_MAX(newCapacity, 1) * sizeof(T));
     1079            AssertReturn(newArr != NULL, false);
    10801080
    10811081            if (m.arr != NULL)
    … …  
    10861086                     * shrink the size. */
    10871087                    for (size_t i = aNewSize; i < m.size; ++ i)
    1088                         Uninit (m.arr [i]);
     1088                        Uninit(m.arr[i]);
    10891089
    10901090                    m.size = aNewSize;
    … …  
    10921092
    10931093                /* Copy the old contents. */
    1094                 memcpy (newArr, m.arr, m.size * sizeof (T));
    1095                 nsMemory::Free ((void *) m.arr);
     1094                memcpy(newArr, m.arr, m.size * sizeof(T));
     1095                nsMemory::Free((void *)m.arr);
    10961096            }
    10971097
    … …  
    11051105                 * shrink the size. */
    11061106                for (size_t i = aNewSize; i < m.size; ++ i)
    1107                     Uninit (m.arr [i]);
     1107                    Uninit(m.arr[i]);
    11081108
    11091109                m.size = aNewSize;
    … …  
    11151115#else
    11161116
    1117         SAFEARRAYBOUND bound = { VarCount (aNewSize), 0 };
     1117        SAFEARRAYBOUND bound = { VarCount(aNewSize), 0 };
    11181118        HRESULT rc;
    11191119
    11201120        if (m.arr == NULL)
    11211121        {
    1122             m.arr = CreateSafeArray (VarType(), &bound);
    1123             AssertReturn (m.arr != NULL, false);
     1122            m.arr = CreateSafeArray(VarType(), &bound);
     1123            AssertReturn(m.arr != NULL, false);
    11241124        }
    11251125        else
    11261126        {
    1127             SafeArrayUnaccessData (m.arr);
    1128 
    1129             rc = SafeArrayRedim (m.arr, &bound);
    1130             AssertComRCReturn (rc == S_OK, false);
    1131         }
    1132 
    1133         rc = SafeArrayAccessData (m.arr, (void HUGEP **) &m.raw);
    1134         AssertComRCReturn (rc, false);
     1127            SafeArrayUnaccessData(m.arr);
     1128
     1129            rc = SafeArrayRedim(m.arr, &bound);
     1130            AssertComRCReturn(rc == S_OK, false);
     1131        }
     1132
     1133        rc = SafeArrayAccessData(m.arr, (void HUGEP **)&m.raw);
     1134        AssertComRCReturn(rc, false);
    11351135
    11361136#endif
    … …  
    11411141    {
    11421142        Data()
    1143             : isWeak (false)
    1144 #if defined (VBOX_WITH_XPCOM)
    1145             , capacity (0), size (0), arr (NULL)
    1146 #else
    1147             , arr (NULL), raw (NULL)
     1143            : isWeak(false)
     1144#ifdef VBOX_WITH_XPCOM
     1145            , capacity(0), size(0), arr(NULL)
     1146#else
     1147            , arr(NULL), raw(NULL)
    11481148#endif
    11491149        {}
    … …  
    11531153        void uninit()
    11541154        {
    1155 #if defined (VBOX_WITH_XPCOM)
     1155#ifdef VBOX_WITH_XPCOM
    11561156
    11571157            if (arr)
    … …  
    11601160                {
    11611161                    for (size_t i = 0; i < size; ++ i)
    1162                         Uninit (arr [i]);
    1163 
    1164                     nsMemory::Free ((void *) arr);
     1162                        Uninit(arr[i]);
     1163
     1164                    nsMemory::Free((void *)arr);
    11651165                }
    11661166                else
    … …  
    11721172            size = capacity = 0;
    11731173
    1174 #else /* defined (VBOX_WITH_XPCOM) */
     1174#else /* !VBOX_WITH_XPCOM */
    11751175
    11761176            if (arr)
    … …  
    11781178                if (raw)
    11791179                {
    1180                     SafeArrayUnaccessData (arr);
     1180                    SafeArrayUnaccessData(arr);
    11811181                    raw = NULL;
    11821182                }
    … …  
    11841184                if (!isWeak)
    11851185                {
    1186                     HRESULT rc = SafeArrayDestroy (arr);
    1187                     AssertComRCReturnVoid (rc);
     1186                    HRESULT rc = SafeArrayDestroy(arr);
     1187                    AssertComRCReturnVoid(rc);
    11881188                }
    11891189                else
    … …  
    11931193            }
    11941194
    1195 #endif /* defined (VBOX_WITH_XPCOM) */
     1195#endif /* !VBOX_WITH_XPCOM */
    11961196        }
    11971197
    11981198        bool isWeak : 1;
    11991199
    1200 #if defined (VBOX_WITH_XPCOM)
     1200#ifdef VBOX_WITH_XPCOM
    12011201        PRUint32 capacity;
    12021202        PRUint32 size;
    … …  
    12441244////////////////////////////////////////////////////////////////////////////////
    12451245
    1246 #if defined (VBOX_WITH_XPCOM)
     1246#ifdef VBOX_WITH_XPCOM
    12471247
    12481248/**
    … …  
    12741274 * this class cannot handle them because of const modifiers.
    12751275 */
    1276 class SafeGUIDArray : public SafeArray <nsID *>
     1276class SafeGUIDArray : public SafeArray<nsID *>
    12771277{
    12781278public:
    12791279
    1280     typedef SafeArray <nsID *> Base;
     1280    typedef SafeArray<nsID *> Base;
    12811281
    12821282    class nsIDRef
    … …  
    12841284    public:
    12851285
    1286         nsIDRef (nsID * &aVal) : mVal (aVal) {}
     1286        nsIDRef(nsID * &aVal) : mVal(aVal) {}
    12871287
    12881288        operator const nsID &() const { return mVal ? *mVal : *Empty; }
    … …  
    12941294        {
    12951295            if (mVal == NULL)
    1296                 Copy (&aThat, mVal);
     1296                Copy(&aThat, mVal);
    12971297            else
    12981298                *mVal = aThat;
    … …  
    13121312    SafeGUIDArray() {}
    13131313
    1314     /** See SafeArray<>::SafeArray (size_t). */
    1315     SafeGUIDArray (size_t aSize) : Base (aSize) {}
     1314    /** See SafeArray<>::SafeArray(size_t). */
     1315    SafeGUIDArray(size_t aSize) : Base(aSize) {}
    13161316
    13171317    /**
    … …  
    13251325    nsIDRef operator[] (size_t aIdx)
    13261326    {
    1327         Assert (m.arr != NULL);
    1328         Assert (aIdx < size());
    1329         return nsIDRef (m.arr [aIdx]);
     1327        Assert(m.arr != NULL);
     1328        Assert(aIdx < size());
     1329        return nsIDRef(m.arr[aIdx]);
    13301330    }
    13311331
    … …  
    13351335    const nsID &operator[] (size_t aIdx) const
    13361336    {
    1337         Assert (m.arr != NULL);
    1338         Assert (aIdx < size());
    1339         return m.arr [aIdx] ? *m.arr [aIdx] : *nsIDRef::Empty;
     1337        Assert(m.arr != NULL);
     1338        Assert(aIdx < size());
     1339        return m.arr[aIdx] ? *m.arr[aIdx] : *nsIDRef::Empty;
    13401340    }
    13411341};
    … …  
    13471347 * implementations. See SafeGUIDArray for more details.
    13481348 */
    1349 class SafeConstGUIDArray : public SafeArray <const nsID *,
    1350                                             SafeArrayTraits <nsID *> >
     1349class SafeConstGUIDArray : public SafeArray<const nsID *,
     1350                                            SafeArrayTraits<nsID *> >
    13511351{
    13521352public:
    13531353
    1354     typedef SafeArray <const nsID *, SafeArrayTraits <nsID *> > Base;
     1354    typedef SafeArray<const nsID *, SafeArrayTraits<nsID *> > Base;
    13551355
    13561356    /** See SafeArray<>::SafeArray(). */
    13571357    SafeConstGUIDArray() {}
    13581358
    1359     /* See SafeArray<>::SafeArray (ComSafeArrayIn (T, aArg)). */
    1360     SafeConstGUIDArray (ComSafeGUIDArrayIn (aArg))
    1361         : Base (ComSafeGUIDArrayInArg (aArg)) {}
     1359    /* See SafeArray<>::SafeArray(ComSafeArrayIn(T, aArg)). */
     1360    SafeConstGUIDArray(ComSafeGUIDArrayIn(aArg))
     1361        : Base(ComSafeGUIDArrayInArg(aArg)) {}
    13621362
    13631363    /**
    … …  
    13701370    const nsID &operator[] (size_t aIdx) const
    13711371    {
    1372         AssertReturn (m.arr != NULL,  **((const nsID * *) NULL));
    1373         AssertReturn (aIdx < size(), **((const nsID * *) NULL));
    1374         return *m.arr [aIdx];
     1372        AssertReturn(m.arr != NULL,  **((const nsID * *)NULL));
     1373        AssertReturn(aIdx < size(), **((const nsID * *)NULL));
     1374        return *m.arr[aIdx];
    13751375    }
    13761376
    … …  
    13781378
    13791379    /* These are disabled because of const. */
    1380     bool reset (size_t aNewSize) { NOREF (aNewSize); return false; }
    1381 };
    1382 
    1383 #else /* defined (VBOX_WITH_XPCOM) */
    1384 
    1385 typedef SafeArray <GUID> SafeGUIDArray;
    1386 typedef SafeArray <const GUID, SafeArrayTraits <GUID> > SafeConstGUIDArray;
    1387 
    1388 #endif /* defined (VBOX_WITH_XPCOM) */
     1380    bool reset(size_t aNewSize) { NOREF(aNewSize); return false; }
     1381};
     1382
     1383#else /* !VBOX_WITH_XPCOM */
     1384
     1385typedef SafeArray<GUID> SafeGUIDArray;
     1386typedef SafeArray<const GUID, SafeArrayTraits<GUID> > SafeConstGUIDArray;
     1387
     1388#endif /* !VBOX_WITH_XPCOM */
    13891389
    13901390////////////////////////////////////////////////////////////////////////////////
    13911391
    1392 #if defined (VBOX_WITH_XPCOM)
    1393 
    1394 template <class I>
     1392#ifdef VBOX_WITH_XPCOM
     1393
     1394template<class I>
    13951395struct SafeIfaceArrayTraits
    13961396{
    13971397protected:
    13981398
    1399     static void Init (I * &aElem) { aElem = NULL; }
    1400     static void Uninit (I * &aElem)
     1399    static void Init(I * &aElem) { aElem = NULL; }
     1400    static void Uninit(I * &aElem)
    14011401    {
    14021402        if (aElem)
    … …  
    14071407    }
    14081408
    1409     static void Copy (I * aFrom, I * &aTo)
     1409    static void Copy(I * aFrom, I * &aTo)
    14101410    {
    14111411        if (aFrom != NULL)
    … …  
    14211421
    14221422    /* Magic to workaround strict rules of par. 4.4.4 of the C++ standard. */
    1423     static I **__asInParam_Arr (I **aArr) { return aArr; }
    1424     static I **__asInParam_Arr (const I **aArr) { return const_cast <I **> (aArr); }
    1425 };
    1426 
    1427 #else /* defined (VBOX_WITH_XPCOM) */
    1428 
    1429 template <class I>
     1423    static I **__asInParam_Arr(I **aArr) { return aArr; }
     1424    static I **__asInParam_Arr(const I **aArr) { return const_cast<I **>(aArr); }
     1425};
     1426
     1427#else /* !VBOX_WITH_XPCOM */
     1428
     1429template<class I>
    14301430struct SafeIfaceArrayTraits
    14311431{
    … …  
    14331433
    14341434    static VARTYPE VarType() { return VT_DISPATCH; }
    1435     static ULONG VarCount (size_t aSize) { return (ULONG) aSize; }
    1436     static size_t Size (ULONG aVarCount) { return (size_t) aVarCount; }
    1437 
    1438     static void Copy (I * aFrom, I * &aTo)
     1435    static ULONG VarCount(size_t aSize) { return (ULONG)aSize; }
     1436    static size_t Size(ULONG aVarCount) { return (size_t)aVarCount; }
     1437
     1438    static void Copy(I * aFrom, I * &aTo)
    14391439    {
    14401440        if (aFrom != NULL)
    … …  
    14471447    }
    14481448
    1449     static SAFEARRAY *CreateSafeArray (VARTYPE aVarType, SAFEARRAYBOUND *aBound)
    1450     {
    1451         NOREF (aVarType);
    1452         return SafeArrayCreateEx (VT_DISPATCH, 1, aBound, (PVOID) &_ATL_IIDOF (I));
    1453     }
    1454 };
    1455 
    1456 #endif /* defined (VBOX_WITH_XPCOM) */
     1449    static SAFEARRAY *CreateSafeArray(VARTYPE aVarType, SAFEARRAYBOUND *aBound)
     1450    {
     1451        NOREF(aVarType);
     1452        return SafeArrayCreateEx(VT_DISPATCH, 1, aBound, (PVOID)&_ATL_IIDOF(I));
     1453    }
     1454};
     1455
     1456#endif /* !VBOX_WITH_XPCOM */
    14571457
    14581458////////////////////////////////////////////////////////////////////////////////
    … …  
    14661466 * @param I     Interface class (no asterisk).
    14671467 */
    1468 template <class I>
    1469 class SafeIfaceArray : public SafeArray <I *, SafeIfaceArrayTraits <I> >
     1468template<class I>
     1469class SafeIfaceArray : public SafeArray<I *, SafeIfaceArrayTraits<I> >
    14701470{
    14711471public:
    14721472
    1473     typedef SafeArray <I *, SafeIfaceArrayTraits <I> > Base;
     1473    typedef SafeArray<I *, SafeIfaceArrayTraits<I> > Base;
    14741474
    14751475    /**
    … …  
    14891489     *       The constructor will also assert in this case.
    14901490     */
    1491     SafeIfaceArray (size_t aSize) { Base::resize (aSize); }
     1491    SafeIfaceArray(size_t aSize) { Base::resize(aSize); }
    14921492
    14931493    /**
    … …  
    14971497     * this:
    14981498     * <pre>
    1499      *  SafeArray safeArray (ComSafeArrayInArg (aArg));
     1499     *  SafeArray safeArray(ComSafeArrayInArg(aArg));
    15001500     * </pre>
    15011501     *
    … …  
    15061506     * @param aArg  Input method parameter to attach to.
    15071507     */
    1508     SafeIfaceArray (ComSafeArrayIn (I *, aArg))
    1509     {
    1510 #if defined (VBOX_WITH_XPCOM)
    1511 
    1512         AssertReturnVoid (aArg != NULL);
     1508    SafeIfaceArray(ComSafeArrayIn(I *, aArg))
     1509    {
     1510#ifdef VBOX_WITH_XPCOM
     1511
     1512        AssertReturnVoid(aArg != NULL);
    15131513
    15141514        Base::m.size = aArgSize;
    … …  
    15161516        Base::m.isWeak = true;
    15171517
    1518 #else /* defined (VBOX_WITH_XPCOM) */
    1519 
    1520         AssertReturnVoid (aArg != NULL);
     1518#else /* !VBOX_WITH_XPCOM */
     1519
     1520        AssertReturnVoid(aArg != NULL);
    15211521        SAFEARRAY *arg = aArg;
    15221522
    15231523        if (arg)
    15241524        {
    1525             AssertReturnVoid (arg->cDims == 1);
     1525            AssertReturnVoid(arg->cDims == 1);
    15261526
    15271527            VARTYPE vt;
    1528             HRESULT rc = SafeArrayGetVartype (arg, &vt);
    1529             AssertComRCReturnVoid (rc);
    1530             AssertMsgReturnVoid (vt == VT_UNKNOWN || vt == VT_DISPATCH,
    1531                                  ("Expected vartype VT_UNKNOWN, got %d.\n",
    1532                                   VarType(), vt));
     1528            HRESULT rc = SafeArrayGetVartype(arg, &vt);
     1529            AssertComRCReturnVoid(rc);
     1530            AssertMsgReturnVoid(vt == VT_UNKNOWN || vt == VT_DISPATCH,
     1531                                ("Expected vartype VT_UNKNOWN, got %d.\n",
     1532                                 VarType(), vt));
    15331533            GUID guid;
    1534             rc = SafeArrayGetIID (arg, &guid);
    1535             AssertComRCReturnVoid (rc);
    1536             AssertMsgReturnVoid (InlineIsEqualGUID (_ATL_IIDOF (I), guid),
    1537                                  ("Expected IID {%RTuuid}, got {%RTuuid}.\n",
    1538                                   &_ATL_IIDOF (I), &guid));
    1539 
    1540             rc = SafeArrayAccessData (arg, (void HUGEP **) &m.raw);
    1541             AssertComRCReturnVoid (rc);
     1534            rc = SafeArrayGetIID(arg, &guid);
     1535            AssertComRCReturnVoid(rc);
     1536            AssertMsgReturnVoid(InlineIsEqualGUID(_ATL_IIDOF(I), guid),
     1537                                ("Expected IID {%RTuuid}, got {%RTuuid}.\n",
     1538                                 &_ATL_IIDOF(I), &guid));
     1539
     1540            rc = SafeArrayAccessData(arg, (void HUGEP **)&m.raw);
     1541            AssertComRCReturnVoid(rc);
    15421542        }
    15431543
    … …  
    15451545        m.isWeak = true;
    15461546
    1547 #endif /* defined (VBOX_WITH_XPCOM) */
     1547#endif /* !VBOX_WITH_XPCOM */
    15481548    }
    15491549
    15501550    /**
    15511551     * Creates a deep copy of the given standard C++ container that stores
    1552      * interface pointers as objects of the ComPtr <I> class.
     1552     * interface pointers as objects of the ComPtr<I> class.
    15531553     *
    15541554     * @param aCntr Container object to copy.
    … …  
    15591559     * @param OI    Argument to the ComPtr template (deduced from @c aCntr).
    15601560     */
    1561     template <template <typename, typename> class C, class A, class OI>
    1562     SafeIfaceArray (const C <ComPtr <OI>, A> & aCntr)
    1563     {
    1564         typedef C <ComPtr <OI>, A> List;
    1565 
    1566         Base::resize (aCntr.size());
    1567         AssertReturnVoid (!Base::isNull());
     1561    template<template<typename, typename> class C, class A, class OI>
     1562    SafeIfaceArray(const C<ComPtr<OI>, A> & aCntr)
     1563    {
     1564        typedef C<ComPtr<OI>, A> List;
     1565
     1566        Base::resize(aCntr.size());
     1567        AssertReturnVoid(!Base::isNull());
    15681568
    15691569        int i = 0;
    15701570        for (typename List::const_iterator it = aCntr.begin();
    15711571             it != aCntr.end(); ++ it, ++ i)
    1572 #if defined (VBOX_WITH_XPCOM)
    1573             Copy (*it, Base::m.arr [i]);
    1574 #else
    1575             Copy (*it, Base::m.raw [i]);
     1572#ifdef VBOX_WITH_XPCOM
     1573            Copy(*it, Base::m.arr[i]);
     1574#else
     1575            Copy(*it, Base::m.raw[i]);
    15761576#endif
    15771577    }
    … …  
    15791579    /**
    15801580     * Creates a deep copy of the given standard C++ container that stores
    1581      * interface pointers as objects of the ComObjPtr <I> class.
     1581     * interface pointers as objects of the ComObjPtr<I> class.
    15821582     *
    15831583     * @param aCntr Container object to copy.
    … …  
    15881588     * @param OI    Argument to the ComObjPtr template (deduced from @c aCntr).
    15891589     */
    1590     template <template <typename, typename> class C, class A, class OI>
    1591     SafeIfaceArray (const C <ComObjPtr <OI>, A> & aCntr)
    1592     {
    1593         typedef C <ComObjPtr <OI>, A> List;
    1594 
    1595         Base::resize (aCntr.size());
    1596         AssertReturnVoid (!Base::isNull());
     1590    template<template<typename, typename> class C, class A, class OI>
     1591    SafeIfaceArray(const C<ComObjPtr<OI>, A> & aCntr)
     1592    {
     1593        typedef C<ComObjPtr<OI>, A> List;
     1594
     1595        Base::resize(aCntr.size());
     1596        AssertReturnVoid(!Base::isNull());
    15971597
    15981598        int i = 0;
    15991599        for (typename List::const_iterator it = aCntr.begin();
    16001600             it != aCntr.end(); ++ it, ++ i)
    1601 #if defined (VBOX_WITH_XPCOM)
    1602             Copy (*it, Base::m.arr [i]);
    1603 #else
    1604             Copy (*it, Base::m.raw [i]);
     1601#ifdef VBOX_WITH_XPCOM
     1602            Copy(*it, Base::m.arr[i]);
     1603#else
     1604            Copy(*it, Base::m.raw[i]);
    16051605#endif
    16061606    }
    … …  
    16081608    /**
    16091609     * Creates a deep copy of the given standard C++ map whose values are
    1610      * interface pointers stored as objects of the ComPtr <I> class.
     1610     * interface pointers stored as objects of the ComPtr<I> class.
    16111611     *
    16121612     * @param aMap  Map object to copy.
    … …  
    16191619     * @param OI    Argument to the ComPtr template (deduced from @c aCntr).
    16201620     */
    1621     template <template <typename, typename, typename, typename>
     1621    template<template<typename, typename, typename, typename>
    16221622              class C, class L, class A, class K, class OI>
    1623     SafeIfaceArray (const C <K, ComPtr <OI>, L, A> & aMap)
    1624     {
    1625         typedef C <K, ComPtr <OI>, L, A> Map;
    1626 
    1627         Base::resize (aMap.size());
    1628         AssertReturnVoid (!Base::isNull());
     1623    SafeIfaceArray(const C<K, ComPtr<OI>, L, A> & aMap)
     1624    {
     1625        typedef C<K, ComPtr<OI>, L, A> Map;
     1626
     1627        Base::resize(aMap.size());
     1628        AssertReturnVoid(!Base::isNull());
    16291629
    16301630        int i = 0;
    16311631        for (typename Map::const_iterator it = aMap.begin();
    16321632             it != aMap.end(); ++ it, ++ i)
    1633 #if defined (VBOX_WITH_XPCOM)
    1634             Copy (it->second, Base::m.arr [i]);
    1635 #else
    1636             Copy (it->second, Base::m.raw [i]);
     1633#ifdef VBOX_WITH_XPCOM
     1634            Copy(it->second, Base::m.arr[i]);
     1635#else
     1636            Copy(it->second, Base::m.raw[i]);
    16371637#endif
    16381638    }
    … …  
    16401640    /**
    16411641     * Creates a deep copy of the given standard C++ map whose values are
    1642      * interface pointers stored as objects of the ComObjPtr <I> class.
     1642     * interface pointers stored as objects of the ComObjPtr<I> class.
    16431643     *
    16441644     * @param aMap  Map object to copy.
    … …  
    16511651     * @param OI    Argument to the ComObjPtr template (deduced from @c aCntr).
    16521652     */
    1653     template <template <typename, typename, typename, typename>
     1653    template<template<typename, typename, typename, typename>
    16541654              class C, class L, class A, class K, class OI>
    1655     SafeIfaceArray (const C <K, ComObjPtr <OI>, L, A> & aMap)
    1656     {
    1657         typedef C <K, ComObjPtr <OI>, L, A> Map;
    1658 
    1659         Base::resize (aMap.size());
    1660         AssertReturnVoid (!Base::isNull());
     1655    SafeIfaceArray(const C<K, ComObjPtr<OI>, L, A> & aMap)
     1656    {
     1657        typedef C<K, ComObjPtr<OI>, L, A> Map;
     1658
     1659        Base::resize(aMap.size());
     1660        AssertReturnVoid(!Base::isNull());
    16611661
    16621662        int i = 0;
    16631663        for (typename Map::const_iterator it = aMap.begin();
    16641664             it != aMap.end(); ++ it, ++ i)
    1665 #if defined (VBOX_WITH_XPCOM)
    1666             Copy (it->second, Base::m.arr [i]);
    1667 #else
    1668             Copy (it->second, Base::m.raw [i]);
     1665#ifdef VBOX_WITH_XPCOM
     1666            Copy(it->second, Base::m.arr[i]);
     1667#else
     1668            Copy(it->second, Base::m.raw[i]);
    16691669#endif
    16701670    }
    … …  
    16721672    void setElement(size_t iIdx, I* obj)
    16731673    {
    1674 #if defined (VBOX_WITH_XPCOM)
    1675         Copy (obj, Base::m.arr [iIdx]);
    1676 #else
    1677         Copy (obj, Base::m.raw [iIdx]);
     1674#ifdef VBOX_WITH_XPCOM
     1675        Copy(obj, Base::m.arr[iIdx]);
     1676#else
     1677        Copy(obj, Base::m.raw[iIdx]);
    16781678#endif
    16791679    }
Note: See TracChangeset for help on using the changeset viewer.

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