Changeset 85289 in vbox for trunk/include/VBox

Timestamp:

Jul 13, 2020 12:21:34 AM (5 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

139266

Message:

VBox/com/array.h: Probably a good idea to check the com::SafeArray::resize result before copying over new array content in the initFrom() methods and other places. Made the initFrom() methods return HRESULT. Ditto cloneTo(). bugref:9790

File:

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

trunk/include/VBox/com/array.h

@@ -1012 +1012 @@
     }
 
-    void cloneTo(SafeArray<T>& aOther) const
+    HRESULT cloneTo(SafeArray<T>& aOther) const
     {
         aOther.reset(size());
-        aOther.initFrom(*this);
+        return aOther.initFrom(*this);
     }
 
@@ -1088 +1088 @@
     }
 
-    inline void initFrom(const com::SafeArray<T> & aRef);
-    inline void initFrom(const T* aPtr, size_t aSize);
+    inline HRESULT initFrom(const com::SafeArray<T> & aRef);
+    inline HRESULT initFrom(const T* aPtr, size_t aSize);
 
     // Public methods for internal purposes only.
@@ -1295 +1295 @@
 /* Few fast specializations for primitive array types */
 template<>
-inline void com::SafeArray<BYTE>::initFrom(const com::SafeArray<BYTE> & aRef)
+inline HRESULT com::SafeArray<BYTE>::initFrom(const com::SafeArray<BYTE> & aRef)
 {
     size_t sSize = aRef.size();
-    resize(sSize);
-    ::memcpy(raw(), aRef.raw(), sSize);
+    if (resize(sSize))
+    {
+        ::memcpy(raw(), aRef.raw(), sSize);
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 template<>
-inline void com::SafeArray<BYTE>::initFrom(const BYTE* aPtr, size_t aSize)
-{
-    resize(aSize);
-    ::memcpy(raw(), aPtr, aSize);
+inline HRESULT com::SafeArray<BYTE>::initFrom(const BYTE *aPtr, size_t aSize)
+{
+    if (resize(aSize))
+    {
+        ::memcpy(raw(), aPtr, aSize);
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 
 
 template<>
-inline void com::SafeArray<SHORT>::initFrom(const com::SafeArray<SHORT> & aRef)
+inline HRESULT com::SafeArray<SHORT>::initFrom(const com::SafeArray<SHORT> & aRef)
 {
     size_t sSize = aRef.size();
-    resize(sSize);
-    ::memcpy(raw(), aRef.raw(), sSize * sizeof(SHORT));
+    if (resize(sSize))
+    {
+        ::memcpy(raw(), aRef.raw(), sSize * sizeof(SHORT));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 template<>
-inline void com::SafeArray<SHORT>::initFrom(const SHORT* aPtr, size_t aSize)
-{
-    resize(aSize);
-    ::memcpy(raw(), aPtr, aSize * sizeof(SHORT));
+inline HRESULT com::SafeArray<SHORT>::initFrom(const SHORT *aPtr, size_t aSize)
+{
+    if (resize(aSize))
+    {
+        ::memcpy(raw(), aPtr, aSize * sizeof(SHORT));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 
 template<>
-inline void com::SafeArray<USHORT>::initFrom(const com::SafeArray<USHORT> & aRef)
+inline HRESULT com::SafeArray<USHORT>::initFrom(const com::SafeArray<USHORT> & aRef)
 {
     size_t sSize = aRef.size();
-    resize(sSize);
-    ::memcpy(raw(), aRef.raw(), sSize * sizeof(USHORT));
+    if (resize(sSize))
+    {
+        ::memcpy(raw(), aRef.raw(), sSize * sizeof(USHORT));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 template<>
-inline void com::SafeArray<USHORT>::initFrom(const USHORT* aPtr, size_t aSize)
-{
-    resize(aSize);
-    ::memcpy(raw(), aPtr, aSize * sizeof(USHORT));
+inline HRESULT com::SafeArray<USHORT>::initFrom(const USHORT *aPtr, size_t aSize)
+{
+    if (resize(aSize))
+    {
+        ::memcpy(raw(), aPtr, aSize * sizeof(USHORT));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 
 template<>
-inline void com::SafeArray<LONG>::initFrom(const com::SafeArray<LONG> & aRef)
+inline HRESULT com::SafeArray<LONG>::initFrom(const com::SafeArray<LONG> & aRef)
 {
     size_t sSize = aRef.size();
-    resize(sSize);
-    ::memcpy(raw(), aRef.raw(), sSize * sizeof(LONG));
+    if (resize(sSize))
+    {
+        ::memcpy(raw(), aRef.raw(), sSize * sizeof(LONG));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }
 template<>
-inline void com::SafeArray<LONG>::initFrom(const LONG* aPtr, size_t aSize)
-{
-    resize(aSize);
-    ::memcpy(raw(), aPtr, aSize * sizeof(LONG));
+inline HRESULT com::SafeArray<LONG>::initFrom(const LONG *aPtr, size_t aSize)
+{
+    if (resize(aSize))
+    {
+        ::memcpy(raw(), aPtr, aSize * sizeof(LONG));
+        return S_OK;
+    }
+    return E_OUTOFMEMORY;
 }