Changeset 15042 in vbox for trunk/include/VBox

Timestamp:

Dec 5, 2008 1:38:10 PM (16 years ago)

Author:

vboxsync

Message:

Main/SafeArray: Added SafeArray::push_back() and attachedRaw(); implemented dynamic size change using resize(). Fixed a number of bugs (did't affect the old code but could pop up in the new).

File:

• trunk/include/VBox/com/array.h (modified) (33 diffs)

trunk/include/VBox/com/array.h

@@ -359 +359 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+struct SafeArrayTraitsBase
+{
+protected:
+
+    static SAFEARRAY *CreateSafeArray (VARTYPE aVarType, SAFEARRAYBOUND *aBound)
+    { return SafeArrayCreate (aVarType, 1, aBound); }
+};
+
 /**
  * Provides various helpers for SafeArray.
@@ -381 +389 @@
  */
 template <typename T>
-struct SafeArrayTraits
-{
+struct SafeArrayTraits : public SafeArrayTraitsBase
+{
+protected:
+
     // Arbitrary types are treated as passed by value and each value is
     // represented by a number of VT_Ix type elements where VT_Ix has the
@@ -425 +435 @@
 
 template<>
-struct SafeArrayTraits <LONG>
+struct SafeArrayTraits <LONG> : public SafeArrayTraitsBase
 {
 protected:
@@ -437 +447 @@
 
 template<>
-struct SafeArrayTraits <ULONG>
+struct SafeArrayTraits <ULONG> : public SafeArrayTraitsBase
 {
 protected:
@@ -449 +459 @@
 
 template<>
-struct SafeArrayTraits <LONG64>
+struct SafeArrayTraits <LONG64> : public SafeArrayTraitsBase
 {
 protected:
@@ -461 +471 @@
 
 template<>
-struct SafeArrayTraits <ULONG64>
+struct SafeArrayTraits <ULONG64> : public SafeArrayTraitsBase
 {
 protected:
@@ -473 +483 @@
 
 template<>
-struct SafeArrayTraits <BSTR>
+struct SafeArrayTraits <BSTR> : public SafeArrayTraitsBase
 {
 protected:
@@ -488 +498 @@
 
 template<>
-struct SafeArrayTraits <GUID>
+struct SafeArrayTraits <GUID> : public SafeArrayTraitsBase
 {
 protected:
@@ -505 +515 @@
 
     static void Copy (GUID aFrom, GUID &aTo) { aTo = aFrom; }
+};
+
+/**
+ * Helper for SafeArray::__asOutParam() that automatically updates m.raw after a
+ * non-NULL m.arr assignment.
+ */
+class OutSafeArrayDipper
+{
+    OutSafeArrayDipper (SAFEARRAY **aArr, void **aRaw)
+        : arr (aArr), raw (aRaw) { Assert (*aArr == NULL && *aRaw == NULL); }
+
+    SAFEARRAY **arr;
+    void **raw;
+
+    template <class, class> friend class SafeArray;
+
+public:
+
+    ~OutSafeArrayDipper()
+    {
+        if (*arr != NULL)
+        {
+            HRESULT rc = SafeArrayAccessData (*arr, raw);
+            AssertComRC (rc);
+        }
+    }
+
+    operator SAFEARRAY **() { return arr; }
 };
 
@@ -551 +589 @@
      * array initialized with null values.
      *
-     * @param aSize     Initial number of elements in the array. Must be greater
-     *                  than 0.
+     * @param aSize     Initial number of elements in the array.
      *
      * @note If this object remains null after construction it means that there
@@ -558 +595 @@
      *       The constructor will also assert in this case.
      */
-    SafeArray (size_t aSize) { reset (aSize); }
+    SafeArray (size_t aSize) { resize (aSize); }
 
     /**
@@ -600 +637 @@
                                  ("Expected vartype %d, got %d.\n",
                                   VarType(), vt));
+
+            rc = SafeArrayAccessData (arg, (void HUGEP **) &m.raw);
+            AssertComRCReturnVoid (rc);
         }
 
@@ -605 +645 @@
         m.isWeak = true;
 
-        AssertReturnVoid (m.arr == NULL || accessRaw() != NULL);
-
 #endif /* defined (VBOX_WITH_XPCOM) */
     }
@@ -621 +659 @@
     SafeArray (const C <T, A> & aCntr)
     {
-        reset (aCntr.size());
+        resize (aCntr.size());
         AssertReturnVoid (!isNull());
 
@@ -677 +715 @@
 
     /**
+     * Appends a copy of the given element at the end of the array.
+     *
+     * The array size is increased by one by this method and the additional
+     * space is allocated as needed.
+     *
+     * This method is handy in cases where you want to assign a copy of the
+     * existing value to the array element, for example:
+     * <tt>Bstr string; array.push_back (string);</tt>. If you create a string
+     * just to put it to the array, you may find #appendedRaw() more useful.
+     *
+     * @param aElement Element to append.
+     *
+     * @return          @c true on success and false if there is not enough
+     *                  memory for resizing.
+     */
+    bool push_back (const T &aElement)
+    {
+        if (!ensureCapacity (size() + 1))
+            return false;
+
+#if defined (VBOX_WITH_XPCOM)
+        Copy (aElement, m.arr [m.size]);
+        ++ m.size;
+#else
+        Copy (aElement, m.raw [size() - 1]);
+#endif
+        return true;
+    }
+
+    /**
+     * Appends an empty element at the end of the array and returns a raw
+     * pointer to it suitable for assigning a raw value (w/o constructing a
+     * copy).
+     *
+     * The array size is increased by one by this method and the additional
+     * space is allocated as needed.
+     *
+     * Note that in case of raw assignment, value ownership (for types with
+     * dynamically allocated data and for interface pointers) is transferred to
+     * the safe array object.
+     *
+     * This method is handy for operations like
+     * <tt>Bstr ("foo").detacTo (array.appendedRaw());</tt>. Don't use it as
+     * l-value (<tt>array.appendedRaw() = SysAllocString (L"tralala");</tt>)
+     * since this doesn't check for a NULL condition; use #resize() and
+     * #setRawAt() instead. If you need to assign a copy of the existing value
+     * instead of transferring the ownership, look at #push_back().
+     *
+     * @return          Raw pointer to the added element or NULL if no memory.
+     */
+    T *appendedRaw()
+    {
+        if (!ensureCapacity (size() + 1))
+            return NULL;
+
+#if defined (VBOX_WITH_XPCOM)
+        Init (m.arr [m.size]);
+        ++ m.size;
+        return &m.arr [m.size - 1];
+#else
+        /* nothing to do here, SafeArrayCreate() has performed element
+         * initialization */
+        return &m.raw [size() - 1];
+#endif
+    }
+
+    /**
      * Resizes the array preserving its contents when possible. If the new size
-     * is bigger than the old size, new elements are initialized with null
-     * values. If the new size is smaller than the old size, the contents of the
-     * array above the new size is lost.
+     * is larget than the old size, new elements are initialized with null
+     * values. If the new size is less than the old size, the contents of the
+     * array beyond the new size is lost.
      *
      * @param aNewSize  New number of elements in the array.
@@ -686 +791 @@
      *                  memory for resizing.
      */
-    virtual bool resize (size_t aNewSize)
-    {
-        /// @todo Implement me!
-        NOREF (aNewSize);
-        AssertFailedReturn (false);
+    bool resize (size_t aNewSize)
+    {
+        if (!ensureCapacity (aNewSize))
+            return false;
+
+#if defined (VBOX_WITH_XPCOM)
+
+        if (m.size < aNewSize)
+        {
+            /* initialize the new elements */
+            for (size_t i = m.size; i < aNewSize; ++ i)
+                Init (m.arr [i]);
+        }
+
+        m.size = aNewSize;
+#else
+        /* nothing to do here, SafeArrayCreate() has performed element
+         * initialization */
+#endif
+        return true;
     }
 
@@ -701 +821 @@
      *                  memory for resizing.
      */
-    virtual bool reset (size_t aNewSize)
+    bool reset (size_t aNewSize)
     {
         m.uninit();
-
-#if defined (VBOX_WITH_XPCOM)
-
-        /* Note: for zero-sized arrays, we use the size of 1 because whether
-         * malloc(0) returns a null pointer or not (which is used in isNull())
-         * is implementation-dependent according to the C standard. */
-
-        m.arr = (T *) nsMemory::Alloc (RT_MAX (aNewSize, 1) * sizeof (T));
-        AssertReturn (m.arr != NULL, false);
-
-        m.size = aNewSize;
-
-        for (size_t i = 0; i < m.size; ++ i)
-            Init (m.arr [i]);
-
-#else
-
-        SAFEARRAYBOUND bound = { VarCount (aNewSize), 0 };
-        m.arr = SafeArrayCreate (VarType(), 1, &bound);
-        AssertReturn (m.arr != NULL, false);
-
-        AssertReturn (accessRaw() != NULL, false);
-
-#endif
-        return true;
+        return resize (aNewSize);
     }
 
@@ -743 +839 @@
         return m.arr;
 #else
-        return accessRaw();
+        return m.raw;
 #endif
     }
@@ -755 +851 @@
         return m.arr;
 #else
-        return accessRaw();
+        return m.raw;
 #endif
     }
@@ -775 +871 @@
         return m.arr [aIdx];
 #else
-
-        AssertReturn (accessRaw() != NULL,  *((T *) NULL));
+        AssertReturn (m.raw != NULL,  *((T *) NULL));
         return m.raw [aIdx];
 #endif
@@ -791 +886 @@
         return m.arr [aIdx];
 #else
-        AssertReturn (unconst (this)->accessRaw() != NULL,  *((T *) NULL));
+        AssertReturn (m.raw != NULL,  *((T *) NULL));
         return m.raw [aIdx];
 #endif
@@ -892 +987 @@
 
     /** Internal function Never call it directly. */
-    SAFEARRAY ** __asOutParam() { setNull(); return &m.arr; }
+    OutSafeArrayDipper __asOutParam()
+    { setNull(); return OutSafeArrayDipper (&m.arr, (void **) &m.raw); }
 
 #endif /* defined (VBOX_WITH_XPCOM) */
@@ -902 +998 @@
     DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SafeArray)
 
-#if defined (VBOX_WITH_XPCOM)
-#else /* defined (VBOX_WITH_XPCOM) */
-
-    /** Requests access to the raw data pointer. */
-    T *accessRaw()
-    {
-        if (m.arr && m.raw == NULL)
-        {
-            HRESULT rc = SafeArrayAccessData (m.arr, (void HUGEP **) &m.raw);
-            AssertComRCReturn (rc, NULL);
-        }
-        return m.raw;
-    }
-
-#endif /* defined (VBOX_WITH_XPCOM) */
+    /**
+     * Ensures that the array is big enough to contaon aNewSize elements.
+     *
+     * If the new size is greater than the current capacity, a new array is
+     * allocated and elements from the old array are copied over. The  size of
+     * the array doesn't change, only the capacity increases (which is always
+     * greater than the size). Note that the additionally allocated elements are
+     * left uninitialized by this method.
+     *
+     * If the new size is less than the current size, the existing array is
+     * truncated to the specified size and the elements outside the new array
+     * boundary are freed.
+     *
+     * If the new size is the same as the current size, nothing happens.
+     *
+     * @param aNewSize  New size of the array.
+     *
+     * @return @c true on success and @c false if not enough memory.
+     */
+    bool ensureCapacity (size_t aNewSize)
+    {
+        AssertReturn (!m.isWeak, false);
+
+#if defined (VBOX_WITH_XPCOM)
+
+        /* Note: we distinguish between a null array and an empty (zero
+         * elements) array. Therefore we never use zero in malloc (even if
+         * aNewSize is zero) to make sure we get a non-null pointer. */
+
+        if (m.size == aNewSize && m.arr != NULL)
+            return true;
+
+        /* allocate in 16-byte pieces */
+        size_t newCapacity = RT_MAX ((aNewSize + 15) / 16 * 16, 16);
+
+        if (m.capacity != newCapacity)
+        {
+            T *newArr = (T *) nsMemory::Alloc (RT_MAX (newCapacity, 1) * sizeof (T));
+            AssertReturn (newArr != NULL, false);
+
+            if (m.arr != NULL)
+            {
+                if (m.size > aNewSize)
+                {
+                    /* truncation takes place, uninit exceeding elements and
+                     * shrink the size */
+                    for (size_t i = aNewSize; i < m.size; ++ i)
+                        Uninit (m.arr [i]);
+
+                    m.size = aNewSize;
+                }
+
+                /* copy the old contents */
+                memcpy (newArr, m.arr, m.size * sizeof (T));
+                nsMemory::Free ((void *) m.arr);
+            }
+
+            m.arr = newArr;
+        }
+        else
+        {
+            if (m.size > aNewSize)
+            {
+                /* truncation takes place, uninit exceeding elements and
+                 * shrink the size */
+                for (size_t i = aNewSize; i < m.size; ++ i)
+                    Uninit (m.arr [i]);
+
+                m.size = aNewSize;
+            }
+        }
+
+        m.capacity = newCapacity;
+
+#else
+
+        SAFEARRAYBOUND bound = { VarCount (aNewSize), 0 };
+        HRESULT rc;
+
+        if (m.arr == NULL)
+        {
+            m.arr = CreateSafeArray (VarType(), &bound);
+            AssertReturn (m.arr != NULL, false);
+        }
+        else
+        {
+            SafeArrayUnaccessData (m.arr);
+
+            rc = SafeArrayRedim (m.arr, &bound);
+            AssertComRCReturn (rc == S_OK, false);
+        }
+
+        rc = SafeArrayAccessData (m.arr, (void HUGEP **) &m.raw);
+        AssertComRCReturn (rc, false);
+
+#endif
+        return true;
+    }
 
     struct Data
@@ -923 +1102 @@
             : isWeak (false)
 #if defined (VBOX_WITH_XPCOM)
-            , size (0), arr (NULL)
+            , capacity (0), size (0), arr (NULL)
 #else
             , arr (NULL), raw (NULL)
@@ -943 +1122 @@
 
                     nsMemory::Free ((void *) arr);
-
+                }
+                else
                     isWeak = false;
-                }
+
                 arr = NULL;
             }
+
+            size = capacity = 0;
 
 #else /* defined (VBOX_WITH_XPCOM) */
@@ -963 +1145 @@
                     HRESULT rc = SafeArrayDestroy (arr);
                     AssertComRCReturnVoid (rc);
-
+                }
+                else
                     isWeak = false;
-                }
+
                 arr = NULL;
             }
@@ -975 +1158 @@
 
 #if defined (VBOX_WITH_XPCOM)
+        PRUint32 capacity;
         PRUint32 size;
         T *arr;
@@ -1190 +1374 @@
             aTo = NULL;
     }
+
+    static SAFEARRAY *CreateSafeArray (VARTYPE aVarType, SAFEARRAYBOUND *aBound)
+    {
+        NOREF (aVarType);
+        return SafeArrayCreateEx (VT_UNKNOWN, 1, aBound, (PVOID) &_ATL_IIDOF (I));
+    }
 };
 
@@ -1227 +1417 @@
      *       The constructor will also assert in this case.
      */
-    SafeIfaceArray (size_t aSize) { reset (aSize); }
+    SafeIfaceArray (size_t aSize) { resize (aSize); }
 
     /**
@@ -1275 +1465 @@
                                  ("Expected IID {%Vuuid}, got {%Vuuid}.\n",
                                   &_ATL_IIDOF (I), &guid));
+
+            rc = SafeArrayAccessData (arg, (void HUGEP **) &m.raw);
+            AssertComRCReturnVoid (rc);
         }
 
         m.arr = arg;
         m.isWeak = true;
-
-        AssertReturnVoid (accessRaw() != NULL);
 
 #endif /* defined (VBOX_WITH_XPCOM) */
@@ -1301 +1492 @@
         typedef C <ComPtr <OI>, A> List;
 
-        reset (aCntr.size());
+        resize (aCntr.size());
         AssertReturnVoid (!Base::isNull());
 
@@ -1330 +1521 @@
         typedef C <ComObjPtr <OI>, A> List;
 
-        reset (aCntr.size());
+        resize (aCntr.size());
         AssertReturnVoid (!Base::isNull());
 
@@ -1342 +1533 @@
 #endif
     }
-
-    /**
-     * Reinitializes this instance by preallocating space for the given number
-     * of elements. The previous array contents is lost.
-     *
-     * @param aNewSize  New number of elements in the array.
-     * @return          @c true on success and false if there is not enough
-     *                  memory for resizing.
-     */
-    virtual bool reset (size_t aNewSize)
-    {
-        Base::m.uninit();
-
-#if defined (VBOX_WITH_XPCOM)
-
-        /* Note: for zero-sized arrays, we use the size of 1 because whether
-         * malloc(0) returns a null pointer or not (which is used in isNull())
-         * is implementation-dependent according to the C standard. */
-
-        Base::m.arr = (I **) nsMemory::Alloc (RT_MAX (aNewSize, 1) * sizeof (I *));
-        AssertReturn (Base::m.arr != NULL, false);
-
-        Base::m.size = aNewSize;
-
-        for (size_t i = 0; i < Base::m.size; ++ i)
-            Init (Base::m.arr [i]);
-
-#else
-
-        SAFEARRAYBOUND bound = { (ULONG)aNewSize, 0 };
-        m.arr = SafeArrayCreateEx (VT_UNKNOWN, 1, &bound,
-                                   (PVOID) &_ATL_IIDOF (I));
-        AssertReturn (m.arr != NULL, false);
-
-        AssertReturn (accessRaw() != NULL, false);
-
-#endif
-        return true;
-    }
 };