UT_SGuid.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_SGuid.h
 *
 * COMMENTS:
 *
 *  A small guid implementation. A "small" guid uses 64 bits instead of 128 and
 *  is not truly globally unique. A "small" guid is meant to be used in cases
 *  where uniqueness is necessary but space is equally as important. If true
 *  "guaranteed" uniqueness is required then UT_Guid should be used instead
 *  at the cost of space.
 *
 *  reference: https://devblogs.microsoft.com/oldnewthing/20080627-00/?p=21823
 */

#ifndef __UT_SGUID_H__
#define __UT_SGUID_H__

#include "UT_API.h"

#include "UT_ORMColumnType.h"

#include <SYS/SYS_Hash.h>
#include <SYS/SYS_Math.h>

class UT_StringHolder;
class UT_IStream;
class UT_WorkBuffer;
class UT_StringRef;
class UT_SqlStatement;

class UT_API UT_SGuid
{
public:
    UT_SGuid(bool generate=true);
    explicit UT_SGuid(const UT_StringRef& src);

    UT_SGuid(const UT_SGuid& other);
    UT_SGuid& operator=(const UT_SGuid& other);

    UT_SGuid(UT_SGuid&&) = default;
    UT_SGuid& operator=(UT_SGuid&&) = default;

    UT_SGuid& operator=(const UT_StringHolder& str);

    bool setString(const UT_StringRef& src);
    UT_StringHolder toString() const;
    void getString(UT_StringHolder& str) const;
    void getString(UT_WorkBuffer& str) const;
    void setFromInt(uint64 value);

    void writeBinary(std::ostream& os) const;
    bool readBinary(UT_IStream& is);
    bool readAscii(UT_IStream& is);

    /// Set the machine id if you need to identify the specific machine within
    /// a cluster.
    static void setMachineId(uint32 machine_id);

    size_t hash() const
    {
        generateIfEmpty_();

        size_t h = SYSwang_inthash(myHigh);
        SYShashCombine(h, SYSwang_inthash(myLow));
        return h;
    }

    bool operator==(const UT_SGuid& sguid) const;
    bool operator!=(const UT_SGuid& sguid) const { return !(*this == sguid); }

    friend UT_API std::ostream& operator<<(
            std::ostream& os,
            const UT_SGuid& guid);

    SYS_NO_DISCARD_RESULT uint64 toInt64() const
    {
        return (uint64)myHigh << 32 | myLow;
    }

private:
    /// Generate the sguid for the object
    void generate_();
    /// Check if this object has a value already
    bool isEmpty_() const { return myHigh == 0 && myLow == 0; }
    /// Generate the id for the object if its currently empty. This allows users
    /// to lazy load the id. In cases where the sguid is being loaded in this
    /// allows the caller to generate an ID once instead of twice.
    void generateIfEmpty_() const
    {
        if (isEmpty_())
        {
            const_cast<UT_SGuid*>(this)->generate_();
        }
    }

    uint32 myHigh;
    uint32 myLow;

    static uint32 theMachineId;
};

inline size_t
hash_value(const UT_SGuid& guid)
{
    return guid.hash();
}

UT_API bool UTsqlBind(UT_SqlStatement& stmt, int idx, const UT_SGuid& sguid);
UT_API bool UTsqlGet(const UT_SqlStatement& stmt, int idx, UT_SGuid& sguid);

template <>
inline UT_ORMColumnType
UTsqlOrmColumnType<UT_SGuid>()
{
    return UT_ORMColumnType::Int64;
}

#endif // __UT_SGUID_H__