Changeset 51688 in vbox for trunk/include

Timestamp:

Jun 23, 2014 1:22:09 PM (11 years ago)

Author:

vboxsync

Message:

Main/Guid: fix regressions

File:

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

trunk/include/VBox/com/Guid.h

@@ -103 +103 @@
     Guid(const char *that)
     {
+        initString(that);
+    }
+
+    /**
+     * Construct a GUID from a BSTR.
+     *
+     * @param   that        The UUID BSTR. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     *                      invalid.
+     */
+    Guid(CBSTR that)
+    {
+        initBSTR(that);
+    }
+
+    /**
+     * Construct a GUID from a Utf8Str.
+     *
+     * @param   that        The UUID Utf8Str. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const Utf8Str &that)
+    {
+        initString(that.c_str());
+    }
+
+    /**
+     * Construct a GUID from a RTCString.
+     *
+     * @param   that        The UUID RTCString. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const RTCString &that)
+    {
+        initString(that.c_str());
+    }
+
+    /**
+     * Construct a GUID from a Bstr.
+     *
+     * @param   that        The UUID Bstr. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const Bstr &that)
+    {
+        initBSTR(that.raw());
+    }
+
+    Guid& operator=(const Guid &that)
+    {
+        mUuid = that.mUuid;
+        mGuidState = that.mGuidState;
+        dbg_refresh();
+        return *this;
+    }
+
+    Guid& operator=(const RTUUID &guid)
+    {
+        mUuid = guid;
+        mGuidState = GUID_NORMAL;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
+        return *this;
+    }
+
+    Guid& operator=(const GUID &guid)
+    {
+        AssertCompileSize(GUID, sizeof(RTUUID));
+        ::memcpy(&mUuid, &guid, sizeof(GUID));
+        mGuidState = GUID_NORMAL;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
+        return *this;
+    }
+
+    Guid& operator=(const char *str)
+    {
+        if (!str || !*str)
+        {
+            ::RTUuidClear(&mUuid);
+            mGuidState = GUID_ZERO;
+        }
+        else
+        {
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromStr(&mUuid, str);
+            if (RT_FAILURE(rc))
+            {
+                ::RTUuidClear(&mUuid);
+                mGuidState = GUID_INVALID;
+            }
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
+        return *this;
+    }
+
+    Guid& operator=(CBSTR str)
+    {
+        if (!str || !*str)
+        {
+            ::RTUuidClear(&mUuid);
+            mGuidState = GUID_ZERO;
+        }
+        else
+        {
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromUtf16(&mUuid, str);
+            if (RT_FAILURE(rc))
+            {
+                ::RTUuidClear(&mUuid);
+                mGuidState = GUID_INVALID;
+            }
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
+        return *this;
+    }
+
+    Guid& operator=(const Utf8Str &str)
+    {
+        return operator=(str.c_str());
+    }
+
+    Guid& operator=(const RTCString &str)
+    {
+        return operator=(str.c_str());
+    }
+
+    Guid& operator=(const Bstr &str)
+    {
+        return operator=(str.raw());
+    }
+
+    void create()
+    {
+        ::RTUuidCreate(&mUuid);
+        mGuidState = GUID_NORMAL;
+        dbg_refresh();
+    }
+
+    void clear()
+    {
+        ::RTUuidClear(&mUuid);
+        mGuidState = GUID_ZERO;
+        dbg_refresh();
+    }
+
+    /**
+     * Convert the GUID to a string.
+     *
+     * @returns String object containing the formatted GUID.
+     * @throws  std::bad_alloc
+     */
+    Utf8Str toString() const
+    {
+        if (mGuidState == GUID_INVALID)
+        {
+            /* What to return in case of wrong Guid */
+            return Utf8Str("00000000-0000-0000-0000-00000000000");
+        }
+
+        char buf[RTUUID_STR_LENGTH];
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToStr(&mUuid, buf, sizeof(buf));
+
+        return Utf8Str(buf);
+    }
+
+    /**
+     * Like toString, but encloses the returned string in curly brackets.
+     *
+     * @returns String object containing the formatted GUID in curly brackets.
+     * @throws  std::bad_alloc
+     */
+    Utf8Str toStringCurly() const
+    {
+        if (mGuidState == GUID_INVALID)
+        {
+            /* What to return in case of wrong Guid */
+            return Utf8Str("{00000000-0000-0000-0000-00000000000}");
+        }
+
+        char buf[RTUUID_STR_LENGTH + 2];
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToStr(&mUuid, buf + 1, sizeof(buf) - 2);
+        buf[0] = '{';
+        buf[sizeof(buf) - 2] = '}';
+
+        return Utf8Str(buf);
+    }
+
+    /**
+     * Convert the GUID to a string.
+     *
+     * @returns Bstr object containing the formatted GUID.
+     * @throws  std::bad_alloc
+     */
+    Bstr toUtf16() const
+    {
+        if (mGuidState == GUID_INVALID)
+        {
+            /* What to return in case of wrong Guid */
+          return Bstr("00000000-0000-0000-0000-00000000000");
+        }
+
+        RTUTF16 buf[RTUUID_STR_LENGTH];
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToUtf16(&mUuid, buf, RT_ELEMENTS(buf));
+
+        return Bstr(buf);
+    }
+
+    bool isValid() const
+    {
+        return mGuidState != GUID_INVALID;
+    }
+
+    bool isZero() const
+    {
+        return mGuidState == GUID_ZERO;
+    }
+
+    bool operator==(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    == 0; }
+    bool operator==(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) == 0; }
+    bool operator==(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) == 0; }
+    bool operator!=(const Guid &that) const { return !operator==(that); }
+    bool operator!=(const GUID &guid) const { return !operator==(guid); }
+    bool operator!=(const RTUUID &guid) const { return !operator==(guid); }
+    bool operator<(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    < 0; }
+    bool operator<(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; }
+    bool operator<(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) < 0; }
+
+    /**
+     * To directly copy the contents to a GUID, or for passing it as an input
+     * parameter of type (const GUID *), the compiler converts. */
+    const GUID &ref() const
+    {
+        return *(const GUID *)&mUuid;
+    }
+
+    /**
+     * To pass instances to printf-like functions.
+     */
+    PCRTUUID raw() const
+    {
+        return (PCRTUUID)&mUuid;
+    }
+
+#if !defined(VBOX_WITH_XPCOM)
+
+    /** To assign instances to OUT_GUID parameters from within the interface
+     * method. */
+    const Guid &cloneTo(GUID *pguid) const
+    {
+        if (pguid)
+            ::memcpy(pguid, &mUuid, sizeof(GUID));
+        return *this;
+    }
+
+    /** To pass instances as OUT_GUID parameters to interface methods. */
+    GUID *asOutParam()
+    {
+        return (GUID *)&mUuid;
+    }
+
+#else
+
+    /** To assign instances to OUT_GUID parameters from within the
+     * interface method */
+    const Guid &cloneTo(nsID **ppGuid) const
+    {
+        if (ppGuid)
+            *ppGuid = (nsID *)nsMemory::Clone(&mUuid, sizeof(nsID));
+
+        return *this;
+    }
+
+    /**
+     * Internal helper class for asOutParam().
+     *
+     * This takes a GUID refrence in the constructor and copies the mUuid from
+     * the method to that instance in its destructor.
+     */
+    class GuidOutParam
+    {
+        GuidOutParam(Guid &guid)
+            : ptr(0),
+              outer(guid)
+        {
+            outer.clear();
+        }
+
+        nsID *ptr;
+        Guid &outer;
+        GuidOutParam(const GuidOutParam &that); // disabled
+        GuidOutParam &operator=(const GuidOutParam &that); // disabled
+    public:
+        operator nsID**() { return &ptr; }
+        ~GuidOutParam()
+        {
+            if (ptr && outer.isEmpty())
+            {
+                outer = *ptr;
+                outer.refresh();
+                nsMemory::Free(ptr);
+            }
+        }
+        friend class Guid;
+    };
+
+    /** to pass instances as OUT_GUID parameters to interface methods */
+    GuidOutParam asOutParam() { return GuidOutParam(*this); }
+
+#endif
+
+    /**
+     *  Static immutable empty (zero) object. May be used for comparison purposes.
+     */
+    static const Guid Empty;
+
+private:
+    void initString(const char *that)
+    {
         if (!that || !*that)
         {
@@ -123 +459 @@
     }
 
-    /**
-     * Construct a GUID from a BSTR.
-     *
-     * @param   that        The UUID BSTR. Can be with or without the curly
-     *                      brackets. Empty strings are translated to a zero
-     *                      GUID, and strings which are not confirming to
-     *                      valid GUID string representations are marked as
-     *                      invalid.
-     */
-    Guid(CBSTR that)
+    void initBSTR(CBSTR that)
     {
         if (!that || !*that)
@@ -155 +482 @@
 
     /**
-     * Construct a GUID from a Utf8Str.
-     *
-     * @param   that        The UUID Utf8Str. Can be with or without the curly
-     *                      brackets. Empty strings are translated to a zero
-     *                      GUID, and strings which are not confirming to
-     *                      valid GUID string representations are marked as
-     */
-    Guid(const Utf8Str &that)
-    {
-        Guid(that.c_str());
-    }
-
-    /**
-     * Construct a GUID from a RTCString.
-     *
-     * @param   that        The UUID RTCString. Can be with or without the curly
-     *                      brackets. Empty strings are translated to a zero
-     *                      GUID, and strings which are not confirming to
-     *                      valid GUID string representations are marked as
-     */
-    Guid(const RTCString &that)
-    {
-        Guid(that.c_str());
-    }
-
-    /**
-     * Construct a GUID from a Bstr.
-     *
-     * @param   that        The UUID Bstr. Can be with or without the curly
-     *                      brackets. Empty strings are translated to a zero
-     *                      GUID, and strings which are not confirming to
-     *                      valid GUID string representations are marked as
-     */
-    Guid(const Bstr &that)
-    {
-        Guid(that.raw());
-    }
-
-    Guid& operator=(const Guid &that)
-    {
-        mUuid = that.mUuid;
-        mGuidState = that.mGuidState;
-        dbg_refresh();
-        return *this;
-    }
-
-    Guid& operator=(const RTUUID &guid)
-    {
-        mUuid = guid;
-        mGuidState = GUID_NORMAL;
-        if (isZero())
-            mGuidState = GUID_ZERO;
-        dbg_refresh();
-        return *this;
-    }
-
-    Guid& operator=(const GUID &guid)
-    {
-        AssertCompileSize(GUID, sizeof(RTUUID));
-        ::memcpy(&mUuid, &guid, sizeof(GUID));
-        mGuidState = GUID_NORMAL;
-        if (isZero())
-            mGuidState = GUID_ZERO;
-        dbg_refresh();
-        return *this;
-    }
-
-    Guid& operator=(const char *str)
-    {
-        if (!str || !*str)
-        {
-            ::RTUuidClear(&mUuid);
-            mGuidState = GUID_ZERO;
-        }
-        else
-        {
-            mGuidState = GUID_NORMAL;
-            int rc = ::RTUuidFromStr(&mUuid, str);
-            if (RT_FAILURE(rc))
-            {
-                ::RTUuidClear(&mUuid);
-                mGuidState = GUID_INVALID;
-            }
-            else if (isZero())
-                mGuidState = GUID_ZERO;
-        }
-        dbg_refresh();
-        return *this;
-    }
-
-    Guid& operator=(CBSTR str)
-    {
-        if (!str || !*str)
-        {
-            ::RTUuidClear(&mUuid);
-            mGuidState = GUID_ZERO;
-        }
-        else
-        {
-            mGuidState = GUID_NORMAL;
-            int rc = ::RTUuidFromUtf16(&mUuid, str);
-            if (RT_FAILURE(rc))
-            {
-                ::RTUuidClear(&mUuid);
-                mGuidState = GUID_INVALID;
-            }
-            else if (isZero())
-                mGuidState = GUID_ZERO;
-        }
-        dbg_refresh();
-        return *this;
-    }
-
-    Guid& operator=(const Utf8Str &str)
-    {
-        return operator=(str.c_str());
-    }
-
-    Guid& operator=(const RTCString &str)
-    {
-        return operator=(str.c_str());
-    }
-
-    Guid& operator=(const Bstr &str)
-    {
-        return operator=(str.raw());
-    }
-
-    void create()
-    {
-        ::RTUuidCreate(&mUuid);
-        mGuidState = GUID_NORMAL;
-        dbg_refresh();
-    }
-
-    void clear()
-    {
-        ::RTUuidClear(&mUuid);
-        mGuidState = GUID_ZERO;
-        dbg_refresh();
-    }
-
-    /**
-     * Convert the GUID to a string.
-     *
-     * @returns String object containing the formatted GUID.
-     * @throws  std::bad_alloc
-     */
-    Utf8Str toString() const
-    {
-        if (mGuidState == GUID_INVALID)
-        {
-            /* What to return in case of wrong Guid */
-            return Utf8Str("00000000-0000-0000-0000-00000000000");
-        }
-
-        char buf[RTUUID_STR_LENGTH];
-        ::memset(buf, '\0', sizeof(buf));
-        ::RTUuidToStr(&mUuid, buf, sizeof(buf));
-
-        return Utf8Str(buf);
-    }
-
-    /**
-     * Like toString, but encloses the returned string in curly brackets.
-     *
-     * @returns String object containing the formatted GUID in curly brackets.
-     * @throws  std::bad_alloc
-     */
-    Utf8Str toStringCurly() const
-    {
-        if (mGuidState == GUID_INVALID)
-        {
-            /* What to return in case of wrong Guid */
-            return Utf8Str("{00000000-0000-0000-0000-00000000000}");
-        }
-
-        char buf[RTUUID_STR_LENGTH + 2];
-        ::memset(buf, '\0', sizeof(buf));
-        ::RTUuidToStr(&mUuid, buf + 1, sizeof(buf) - 2);
-        buf[0] = '{';
-        buf[sizeof(buf) - 2] = '}';
-
-        return Utf8Str(buf);
-    }
-
-    /**
-     * Convert the GUID to a string.
-     *
-     * @returns Bstr object containing the formatted GUID.
-     * @throws  std::bad_alloc
-     */
-    Bstr toUtf16() const
-    {
-        if (mGuidState == GUID_INVALID)
-        {
-            /* What to return in case of wrong Guid */
-          return Bstr("00000000-0000-0000-0000-00000000000");
-        }
-
-        RTUTF16 buf[RTUUID_STR_LENGTH];
-        ::memset(buf, '\0', sizeof(buf));
-        ::RTUuidToUtf16(&mUuid, buf, RT_ELEMENTS(buf));
-
-        return Bstr(buf);
-    }
-
-    bool isValid() const
-    {
-        return mGuidState != GUID_INVALID;
-    }
-
-    bool isZero() const
-    {
-        return mGuidState == GUID_ZERO;
-    }
-
-    bool operator==(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    == 0; }
-    bool operator==(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) == 0; }
-    bool operator==(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) == 0; }
-    bool operator!=(const Guid &that) const { return !operator==(that); }
-    bool operator!=(const GUID &guid) const { return !operator==(guid); }
-    bool operator!=(const RTUUID &guid) const { return !operator==(guid); }
-    bool operator<(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    < 0; }
-    bool operator<(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; }
-    bool operator<(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) < 0; }
-
-    /**
-     * To directly copy the contents to a GUID, or for passing it as an input
-     * parameter of type (const GUID *), the compiler converts. */
-    const GUID &ref() const
-    {
-        return *(const GUID *)&mUuid;
-    }
-
-    /**
-     * To pass instances to printf-like functions.
-     */
-    PCRTUUID raw() const
-    {
-        return (PCRTUUID)&mUuid;
-    }
-
-    /**
-     *  Static immutable empty (zero) object. May be used for comparison purposes.
-     */
-    static const Guid Empty;
-
-private:
-    /**
      * Refresh the debug-only UUID string.
      *