Changeset 13956 in vbox

Timestamp:

Nov 7, 2008 12:41:45 PM (16 years ago)

Author:

vboxsync

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

38988

Message:

Main, FE/Qt: Added support for safe arrays of enums.

Location:

trunk

Files:

• include/VBox/com/array.h (modified) (2 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManage.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/include/COMDefs.h (modified) (1 diff)
• src/VBox/Frontends/VirtualBox4/include/COMDefs.h (modified) (1 diff)
• src/VBox/Main/HardDiskFormatImpl.cpp (modified) (2 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (1 diff)
• src/VBox/Main/include/HardDiskFormatImpl.h (modified) (1 diff)

trunk/include/VBox/com/array.h

@@ -373 +373 @@
     static ULONG VarCount (size_t aSize);
 
-    // Returns the number of elements of T that occupy the given number of
+    // Returns the number of elements of T that fit into the given number of
     // VarType() elements (opposite to VarCount (size_t aSize)).
     static size_t Size (ULONG aVarCount);
@@ -383 +383 @@
 struct SafeArrayTraits
 {
-    // Arbitrary types are not supported -- no helpers
-};
+    // 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
+    // biggest possible bitness necessary to represent T w/o a gap. COM enums
+    // fall into this category.
+
+    static VARTYPE VarType()
+    {
+        if (sizeof (T) % 8 == 0) return VT_I8;
+        if (sizeof (T) % 4 == 0) return VT_I4;
+        if (sizeof (T) % 2 == 0) return VT_I2;
+        return VT_I1;
+    }
+
+    static ULONG VarCount (size_t aSize)
+    {
+        if (sizeof (T) % 8 == 0) return (ULONG) (sizeof (T) / 8) * aSize;
+        if (sizeof (T) % 4 == 0) return (ULONG) (sizeof (T) / 4) * aSize;
+        if (sizeof (T) % 2 == 0) return (ULONG) (sizeof (T) / 2) * aSize;
+        return (ULONG) sizeof (T) * aSize;
+    }
+
+    static size_t Size (ULONG aVarCount)
+    {
+        if (sizeof (T) % 8 == 0) return (size_t) (aVarCount * 8) / sizeof (T);
+        if (sizeof (T) % 4 == 0) return (size_t) (aVarCount * 4) / sizeof (T);
+        if (sizeof (T) % 2 == 0) return (size_t) (aVarCount * 2) / sizeof (T);
+        return (size_t) aVarCount / sizeof (T);
+    }
+
+    static void Copy (T aFrom, T &aTo) { aTo = aFrom; }
+};
+
+template <typename T>
+struct SafeArrayTraits <T *>
+{
+    // Arbitrary pointer types are not supported
+};
+
+/* Although the generic SafeArrayTraits template would work for all integers,
+ * we specialize it for some of them in order to use the correct VT_ type */
 
 template<>

trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

@@ -2825 +2825 @@
             com::SafeArray <BSTR> propertyNames;
             com::SafeArray <BSTR> propertyDescriptions;
-            com::SafeArray <ULONG> propertyTypes;
+            com::SafeArray <DataType_T> propertyTypes;
             com::SafeArray <ULONG> propertyFlags;
             com::SafeArray <BSTR> propertyDefaults;

trunk/src/VBox/Frontends/VirtualBox/include/COMDefs.h

@@ -287 +287 @@
     static void FromSafeArray (const com::SafeGUIDArray &aArr,
                                QValueVector <QUuid> &aVec);
+
+    /* Arrays of enums. Does a cast similar to what ENUMOut does. */
+
+    template <typename QE, typename CE>
+    static void ToSafeArray (const QVector <QE> &aVec,
+                             com::SafeIfaceArray <CE> &aArr)
+    {
+        aArr.reset (static_cast <int> (aVec.size()));
+        for (int i = 0; i < aVec.size(); ++i)
+            aArr [i] = static_cast <CE> (aVec.at (i));
+    }
+
+    template <typename CE, typename QE>
+    static void FromSafeArray (const com::SafeIfaceArray <CE> &aArr,
+                               QVector <QE> &aVec)
+    {
+        aVec.resize (static_cast <int> (aArr.size()));
+        for (int i = 0; i < aVec.size(); ++i)
+            aVec [i] = static_cast <QE> (aArr [i]);
+    }
 
     /* Arrays of interface pointers. Note: we need a separate pair of names

trunk/src/VBox/Frontends/VirtualBox4/include/COMDefs.h

@@ -283 +283 @@
     static void FromSafeArray (const com::SafeGUIDArray &aArr,
                                QVector <QUuid> &aVec);
+
+    /* Arrays of enums. Does a cast similar to what ENUMOut does. */
+
+    template <typename QE, typename CE>
+    static void ToSafeArray (const QVector <QE> &aVec,
+                             com::SafeIfaceArray <CE> &aArr)
+    {
+        aArr.reset (static_cast <int> (aVec.size()));
+        for (int i = 0; i < aVec.size(); ++i)
+            aArr [i] = static_cast <CE> (aVec.at (i));
+    }
+
+    template <typename CE, typename QE>
+    static void FromSafeArray (const com::SafeIfaceArray <CE> &aArr,
+                               QVector <QE> &aVec)
+    {
+        aVec.resize (static_cast <int> (aArr.size()));
+        for (int i = 0; i < aVec.size(); ++i)
+            aVec [i] = static_cast <QE> (aArr [i]);
+    }
 
     /* Arrays of interface pointers. Note: we need a separate pair of names

trunk/src/VBox/Main/HardDiskFormatImpl.cpp

@@ -240 +240 @@
 STDMETHODIMP HardDiskFormat::DescribeProperties(ComSafeArrayOut (BSTR, aNames),
                                                 ComSafeArrayOut (BSTR, aDescriptions),
-                                                ComSafeArrayOut (ULONG, aTypes),
+                                                ComSafeArrayOut (DataType_T, aTypes),
                                                 ComSafeArrayOut (ULONG, aFlags),
                                                 ComSafeArrayOut (BSTR, aDefaults))
@@ -257 +257 @@
     com::SafeArray <BSTR> propertyNames (mData.properties.size());
     com::SafeArray <BSTR> propertyDescriptions (mData.properties.size());
-    com::SafeArray <ULONG> propertyTypes (mData.properties.size());
+    com::SafeArray <DataType_T> propertyTypes (mData.properties.size());
     com::SafeArray <ULONG> propertyFlags (mData.properties.size());
     com::SafeArray <BSTR> propertyDefaults (mData.properties.size());

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -7374 +7374 @@
         <desc>Array of property descriptions.</desc>
       </param>
-      <param name="types" type="unsigned long" safearray="yes" dir="out">
+      <param name="types" type="DataType" safearray="yes" dir="out">
         <desc>Array of property types.</desc>
       </param>

trunk/src/VBox/Main/include/HardDiskFormatImpl.h

@@ -72 +72 @@
     STDMETHOD(DescribeProperties) (ComSafeArrayOut (BSTR, aNames),
                                    ComSafeArrayOut (BSTR, aDescriptions),
-                                   ComSafeArrayOut (ULONG, aTypes),
+                                   ComSafeArrayOut (DataType_T, aTypes),
                                    ComSafeArrayOut (ULONG, aFlags),
                                    ComSafeArrayOut (BSTR, aDefaults));