quuid.cpp

Go to the documentation of this file.

/****************************************************************************
** 
**
** Implementation of QUuid class
**
** Copyright (C) 2000-2001 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "quuid.h"

#include "qdatastream.h"

#ifndef QT_NO_QUUID_STRING

QUuid::QUuid( const QString &text )
{
    bool ok;
    if ( text.isEmpty() ) {
        *this = QUuid();
        return;
    }
    QString temp = text.upper();
    if ( temp[0] != '{' )
        temp = "{" + text;
    if ( text[(int)text.length()-1] != '}' )
        temp += "}";

    data1 = temp.mid( 1, 8 ).toULong( &ok, 16 );
    if ( !ok ) {
        *this = QUuid();
        return;
    }

    data2 = temp.mid( 10, 4 ).toUInt( &ok, 16 );
    if ( !ok ) {
        *this = QUuid();
        return;
    }
    data3 = temp.mid( 15, 4 ).toUInt( &ok, 16 );
    if ( !ok ) {
        *this = QUuid();
        return;
    }
    data4[0] = temp.mid( 20, 2 ).toUInt( &ok, 16 );
    if ( !ok ) {
        *this = QUuid();
        return;
    }
    data4[1] = temp.mid( 22, 2 ).toUInt( &ok, 16 );
    if ( !ok ) {
        *this = QUuid();
        return;
    }
    for ( int i = 2; i<8; i++ ) {
        data4[i] = temp.mid( 25 + (i-2)*2, 2 ).toUShort( &ok, 16 );
        if ( !ok ) {
            *this = QUuid();
            return;
        }
    }
}

QUuid::QUuid( const char *text )
{
    *this = QUuid( QString(text) );
}
#endif

#ifndef QT_NO_QUUID_STRING

QString QUuid::toString() const
{
    QString result;

    result = "{" + QString::number( data1, 16 ).rightJustify( 8, '0' ) + "-";
    result += QString::number( (int)data2, 16 ).rightJustify( 4, '0' ) + "-";
    result += QString::number( (int)data3, 16 ).rightJustify( 4, '0' ) + "-";
    result += QString::number( (int)data4[0], 16 ).rightJustify( 2, '0' );
    result += QString::number( (int)data4[1], 16 ).rightJustify( 2, '0' ) + "-";
    for ( int i = 2; i < 8; i++ )
        result += QString::number( (int)data4[i], 16 ).rightJustify( 2, '0' );

    return result + "}";
}
#endif

#ifndef QT_NO_DATASTREAM

QDataStream &operator<<( QDataStream &s, const QUuid &id )
{
    s << (Q_UINT32)id.data1;
    s << (Q_UINT16)id.data2;
    s << (Q_UINT16)id.data3;
    for (int i = 0; i < 8; i++ )
        s << (Q_UINT8)id.data4[i];
    return s;
}

QDataStream &operator>>( QDataStream &s, QUuid &id )
{
    Q_UINT32 u32;
    Q_UINT16 u16;
    Q_UINT8 u8;
    s >> u32;
    id.data1 = u32;
    s >> u16;
    id.data2 = u16;
    s >> u16;
    id.data3 = u16;
    for (int i = 0; i < 8; i++ ) {
        s >> u8;
        id.data4[i] = u8;
    }
    return s;
}
#endif

bool QUuid::isNull() const
{
    return data4[0] == 0 && data4[1] == 0 && data4[2] == 0 && data4[3] == 0 &&
           data4[4] == 0 && data4[5] == 0 && data4[6] == 0 && data4[7] == 0 &&
           data1 == 0 && data2 == 0 && data3 == 0;
}

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;
}

QUuid::Version QUuid::version() const
{
    // Check the 4 MSB of data3
    Version ver = (Version)(data3>>12);
    if ( isNull() 
         || (variant() != DCE)
         || ver < Time 
         || ver > Random )
        return VerUnknown;
    return ver;
}

#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;
}

#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;
}

#if defined(Q_OS_WIN32)
#include <objbase.h> // For CoCreateGuid
QUuid QUuid::createUuid()
{
    GUID guid;
    CoCreateGuid( &guid );
    QUuid result = guid;
    return result;
}
#else // !Q_OS_WIN32
#include "qdatetime.h"
#include "stdlib.h" // For srand/rand
QUuid QUuid::createUuid()
{
    static const int intbits = sizeof(int)*8;
    static int randbits = 0;
    if ( !randbits ) {
        int max = RAND_MAX;
        do { ++randbits; } while ( (max=max>>1) );
        srand( (uint)QDateTime::currentDateTime().toTime_t() );
        rand(); // Skip first
    }

    QUuid result;
    uint *data = &(result.data1);
    int chunks = 16 / sizeof(uint);
    while ( chunks-- ) {
        uint randNumber = 0;
        for ( int filled = 0; filled < intbits; filled += randbits )
            randNumber |= rand()<<filled;
         *(data+chunks) = randNumber;
    }

    result.data4[0] = (result.data4[0] & 0x3F) | 0x80;  // UV_DCE
    result.data3 = (result.data3 & 0x0FFF) | 0x4000;    // UV_Random

    return result;
}
#endif // !Q_OS_WIN32

---