- solve problems with padded memory - dont use memcpy

2 files changed, 126 insertions, 92 deletions

diff --git a/library/quuid.cpp b/library/quuid.cpp
index 46fd816..36469a8 100644
--- a/library/quuid.cpp
+++ b/library/quuid.cpp
@@ -51,7 +51,9 @@
 
   Creates a copy of the QUuid \a orig.
 */
+
 #ifndef QT_NO_QUUID_STRING
+
 /*!
   Creates a QUuid object from the string \a text. Right now, the function
   can only convert the format {12345678-1234-1234-1234-123456789ABC} and
@@ -63,40 +65,47 @@ QUuid::QUuid( const QString &text )
     QString temp = text.upper();
 
     data1 = temp.mid( 1, 8 ).toULong( &ok, 16 );
-    if ( !ok ) {
+    if ( !ok )
+    {
         *this = QUuid();
         return;
     }
 
     data2 = temp.mid( 10, 4 ).toUInt( &ok, 16 );
-    if ( !ok ) {
+    if ( !ok )
+    {
         *this = QUuid();
         return;
     }
     data3 = temp.mid( 15, 4 ).toUInt( &ok, 16 );
-    if ( !ok ) {
+    if ( !ok )
+    {
         *this = QUuid();
         return;
     }
     data4[0] = temp.mid( 20, 2 ).toUInt( &ok, 16 );
-    if ( !ok ) {
+    if ( !ok )
+    {
         *this = QUuid();
         return;
     }
     data4[1] = temp.mid( 22, 2 ).toUInt( &ok, 16 );
-    if ( !ok ) {
+    if ( !ok )
+    {
         *this = QUuid();
         return;
     }
-    for ( int i = 2; i<8; i++ ) {
+    for ( int i = 2; i<8; i++ )
+    {
         data4[i] = temp.mid( 25 + (i-2)*2, 2 ).toUShort( &ok, 16 );
-        if ( !ok ) {
+        if ( !ok )
+        {
             *this = QUuid();
             return;
         }
     }
 }
-#endif
+
 /*!
   \fn QUuid QUuid::operator=(const QUuid &uuid )
 
@@ -114,7 +123,7 @@ QUuid::QUuid( const QString &text )
 
   Returns TRUE if this QUuid and the \a other QUuid are different, otherwise returns FALSE.
 */
-#ifndef QT_NO_QUUID_STRING
+
 /*!
   QString QUuid::toString() const
 
@@ -135,6 +144,7 @@ QString QUuid::toString() const
     return result + "}";
 }
 #endif
+
 /*!
   Returns TRUE if this is the null UUID {00000000-0000-0000-0000-000000000000}, otherwise returns FALSE.
 */
@@ -144,3 +154,74 @@ bool QUuid::isNull() const
            data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
            data1 == 0 && data2 == 0 && data3 == 0;
 }
+
+
+/*!
+    \fn QUuid::Variant QUuid::variant() const
+
+    Returns the variant of the UUID.
+    The null UUID is considered to be of an unknown variant.
+
+    \sa version()
+*/
+QUuid::Variant QUuid::variant() const
+{
+    if ( isNull() )
+        return VarUnknown;
+    // Check the 3 MSB of data4[0]
+    if ( (data4[0] & 0x80) == 0x00 ) return NCS;
+    else if ( (data4[0] & 0xC0) == 0x80 ) return DCE;
+    else if ( (data4[0] & 0xE0) == 0xC0 ) return Microsoft;
+    else if ( (data4[0] & 0xE0) == 0xE0 ) return Reserved;
+    return VarUnknown;
+}
+
+/*!
+    \fn bool QUuid::operator<(const QUuid &other) const
+
+    Returns TRUE if this QUuid is of the same variant,
+    and lexicographically before the \a other QUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISLESS(f1, f2) if (f1!=f2) return (f1<f2);
+bool QUuid::operator<(const QUuid &other ) const
+{
+    if ( variant() != other.variant() )
+        return FALSE;
+
+    ISLESS( data1, other.data1 );
+    ISLESS( data2, other.data2 );
+    ISLESS( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ )
+    {
+        ISLESS( data4[n], other.data4[n] );
+    }
+    return FALSE;
+}
+
+/*!
+    \fn bool QUuid::operator>(const QUuid &other) const
+
+    Returns TRUE if this QUuid is of the same variant,
+    and lexicographically after the \a other QUuid;
+    otherwise returns FALSE.
+
+    \sa variant()
+*/
+#define ISMORE(f1, f2) if (f1!=f2) return (f1>f2);
+bool QUuid::operator>(const QUuid &other ) const
+{
+    if ( variant() != other.variant() )
+        return FALSE;
+
+    ISMORE( data1, other.data1 );
+    ISMORE( data2, other.data2 );
+    ISMORE( data3, other.data3 );
+    for ( int n = 0; n < 8; n++ )
+    {
+        ISMORE( data4[n], other.data4[n] );
+    }
+    return FALSE;
+}
diff --git a/library/quuid.h b/library/quuid.h
index 841a00f..1575711 100644
--- a/library/quuid.h
+++ b/library/quuid.h
@@ -25,27 +25,16 @@
 #include <qstring.h>
 #endif // QT_H
 
-#include <memory.h>
-
-#if defined(Q_OS_WIN32)
-#ifndef GUID_DEFINED
-#define GUID_DEFINED
-typedef struct _GUID
-{
-    ulong   Data1;
-    ushort  Data2;
-    ushort  Data3;
-    uchar   Data4[ 8 ];
-} GUID;
-#endif
-#endif
-
-#if defined( Q_WS_QWS ) && !defined( UUID_H_INCLUDED )
-typedef unsigned char uuid_t[16];
-#endif
-
 struct Q_EXPORT QUuid
 {
+    enum Variant {
+        VarUnknown  =-1,
+        NCS     = 0, // 0 - -
+        DCE     = 2, // 1 0 -
+        Microsoft   = 6, // 1 1 0
+        Reserved    = 7  // 1 1 1
+    };
+
     QUuid()
     {
         memset( this, 0, sizeof(QUuid) );
@@ -66,8 +55,15 @@ struct Q_EXPORT QUuid
     }
     QUuid( const QUuid &uuid )
     {
-        memcpy( this, &uuid, sizeof(QUuid) );
+        uint i;
+
+        data1 = uuid.data1;
+        data2 = uuid.data2;
+        data3 = uuid.data3;
+        for( i = 0; i < 8; i++ )
+            data4[ i ] = uuid.data4[ i ];
     }
+
 #ifndef QT_NO_QUUID_STRING
     QUuid( const QString & );
     QString toString() const;
@@ -76,83 +72,40 @@ struct Q_EXPORT QUuid
 
     QUuid &operator=(const QUuid &orig )
     {
-        memcpy( this, &orig, sizeof(QUuid) );
-        return *this;
-    }
-
-    bool operator==(const QUuid &orig ) const
-    {
-        return !memcmp( this, &orig, sizeof(QUuid) );
-    }
-
-    bool operator!=(const QUuid &orig ) const
-    {
-        return !( *this == orig );
-    }
-
-    inline bool operator<(const QUuid &orig) const
-    {
-        return ( memcmp(this, &orig, sizeof(QUuid)) < 0);
-    }
-    
-    inline bool operator>(const QUuid &orig) const
-    {
-        return ( memcmp(this, &orig, sizeof(QUuid) ) > 0);
-    }
+        uint i;
     
-#if defined(Q_OS_WIN32)
-    // On Windows we have a type GUID that is used by the platform API, so we
-    // provide convenience operators to cast from and to this type.
-    QUuid( const GUID &guid )
-    {
-        memcpy( this, &guid, sizeof(GUID) );
-    }
+        data1 = orig.data1;
+        data2 = orig.data2;
+        data3 = orig.data3;
+        for( i = 0; i < 8; i++ )
+            data4[ i ] = orig.data4[ i ];
 
-    QUuid &operator=(const GUID &orig )
-    {
-        memcpy( this, &orig, sizeof(QUuid) );
         return *this;
     }
 
-    operator GUID() const
-    {
-        GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } };
-        return guid;
-    }
-
-    bool operator==( const GUID &guid ) const
+    bool operator==(const QUuid &orig ) const
     {
-        return !memcmp( this, &guid, sizeof(QUuid) );
-    }
+        uint i;
+        if ( data1 != orig.data1 || data2 != orig.data2 ||
+                data3 != orig.data3 )
+            return FALSE;
 
-    bool operator!=( const GUID &guid ) const
-    {
-        return !( *this == guid );
-    }
+        for( i = 0; i < 8; i++ )
+            if ( data4[i] != orig.data4[i] )
+                return FALSE;
     
-    inline bool operator<(const QUuid &orig) const
-    {
-        return ( memcmp(this, &orig, sizeof(QUuid) ) < 0);
+        return TRUE;
     }
     
-    inline bool operator>(const QUuid &orig) const
+    bool operator!=(const QUuid &orig ) const
     {
-        return ( memcmp(this, &orig, sizeof(QUuid) ) > 0);
+        return !( *this == orig );
     }
     
-#endif
-#if defined (Q_WS_QWS)
-    QUuid( uuid_t uuid ) 
-    {
-        memcpy( this, uuid, sizeof(uuid_t) );
-    }
+    bool operator<(const QUuid &other ) const;
+    bool operator>(const QUuid &other ) const;
 
-    QUuid &operator=(const uuid_t &orig )
-    {
-        memcpy( this, &orig, sizeof(uuid_t) );
-        return *this;
-    }
-#endif
+    QUuid::Variant variant() const;
     
     ulong   data1;
     ushort  data2;