uuid.h

/*
 *  Copyright (c) 2002-2003    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INLUCDED__SCOPIRA_TOOL_UUID_H_
#define __INLUCDED__SCOPIRA_TOOL_UUID_H_

#include <scopira/tool/export.h>
#include <scopira/tool/platform.h>
#include <scopira/tool/export.h>
#include <scopira/tool/mutex.h>
#include <scopira/tool/flow.h>
#include <scopira/tool/random.h>  // for time_seed
#include <scopira/tool/linconrandom.h>  // for lincon_core

#if (defined(PLATFORM_linux) || defined(PLATFORM_osx)) && !defined(PLATFORM_DONT_USE_LIBUUID)
#define PLATFORM_E2UUID
#endif

#ifdef PLATFORM_E2UUID
#include <uuid/uuid.h>
#endif

// THIS FILE HAS BEEN FULLY DOCUMENTED

namespace scopira
{
  namespace tool
  {
    // rename this to "key" or "ukey" or "token"?
    class uuid;
    class uuid_generator;
  }
}

SCOPIRA_EXPORT scopira::tool::oflow_i& operator << (scopira::tool::oflow_i& o, const scopira::tool::uuid &id);


#ifdef PLATFORM_E2UUID

class scopira::tool::uuid                       // super-Linux implementation
{
  private:
    ::uuid_t dm_id;
  public:
    uuid(void) { ::uuid_clear(dm_id); }
    uuid(const char *s);

    void set_zero(void) { ::uuid_clear(dm_id); }
    bool is_zero(void) const { return ::uuid_is_null(dm_id) != 0; }

    bool operator == (const uuid &rhs) const { return ::uuid_compare(dm_id, rhs.dm_id) == 0; }
    bool operator != (const uuid &rhs) const { return ::uuid_compare(dm_id, rhs.dm_id) != 0; }
    bool operator < (const uuid &rhs) const { return ::uuid_compare(dm_id, rhs.dm_id) < 0; }

    bool load(scopira::tool::itflow_i& in) { return in.read(dm_id, sizeof(dm_id)) == sizeof(dm_id); }
    void save(scopira::tool::otflow_i& out) const { out.write(dm_id, sizeof(dm_id)); }

    std::string as_string(void) const;
    bool parse_string(const std::string &s);

  public:
    friend class scopira::tool::uuid_generator;
    friend scopira::tool::oflow_i& ::operator << (scopira::tool::oflow_i& o, const scopira::tool::uuid &id);
};
#endif

#ifdef PLATFORM_win32

class scopira::tool::uuid                       // super-Win32 implementation
{
  private:
    GUID dm_id;
  public:
    uuid(void) { dm_id = GUID_NULL; }
    uuid(const char *s);

    void set_zero(void) { dm_id = GUID_NULL; }
    bool is_zero(void) const { return *this == uuid(); }

    bool operator == (const uuid &rhs) const { return IsEqualGUID(dm_id, rhs.dm_id) == TRUE; }
    bool operator != (const uuid &rhs) const { return IsEqualGUID(dm_id, rhs.dm_id) == FALSE; }
    SCOPIRA_EXPORT bool operator < (const uuid &rhs) const;

    bool load(scopira::tool::itflow_i& in) { return in.read_void(&dm_id, sizeof(dm_id)) == sizeof(dm_id); }
    void save(scopira::tool::otflow_i& out) const { out.write_void(&dm_id, sizeof(dm_id)); }

    SCOPIRA_EXPORT std::string as_string(void) const;
    SCOPIRA_EXPORT bool parse_string(const std::string &s);

  public:
    friend class scopira::tool::uuid_generator;
    friend scopira::tool::oflow_i& ::operator << (scopira::tool::oflow_i& o, const scopira::tool::uuid &id);
};
#endif

#if !defined(PLATFORM_E2UUID) && !defined(PLATFORM_win32)

class scopira::tool::uuid                       // lame non-Linux implementation[1]
{
  private:
    int64_t dm_id[2];
                  // [1] This implementation will NEED to be synchronized with the Linux
                  // one if there is to be any network communication/collabaration
                  // Under Win32, we'll use MS's GUID stuff, which is basicaly the same thing
                  // What to do for the (non-Linux) UNIXes though?

  public:
    SCOPIRA_EXPORT uuid(void);
    SCOPIRA_EXPORT uuid(const char *s);

    SCOPIRA_EXPORT void set_zero(void);
    SCOPIRA_EXPORT bool is_zero(void) const;

    SCOPIRA_EXPORT bool operator == (const uuid &rhs) const;
    SCOPIRA_EXPORT bool operator != (const uuid &rhs) const;
    SCOPIRA_EXPORT bool operator < (const uuid &rhs) const;

    SCOPIRA_EXPORT bool load(scopira::tool::itflow_i& in);
    SCOPIRA_EXPORT void save(scopira::tool::otflow_i& out) const;

    SCOPIRA_EXPORT std::string as_string(void) const;
    SCOPIRA_EXPORT bool parse_string(const std::string &s);

  public:
    friend class scopira::tool::uuid_generator;
    friend scopira::tool::oflow_i& ::operator << (scopira::tool::oflow_i& o, const scopira::tool::uuid &id);
};
#endif

class scopira::tool::uuid_generator
{
  private:
#if !defined(PLATFORM_E2UUID) && !defined(PLATFORM_win32)
    mutex dm_mut;
    scopira::tool::lincon_core dm_core;
#endif
  public:
#if !defined(PLATFORM_E2UUID) && !defined(PLATFORM_win32)
    SCOPIRA_EXPORT uuid_generator(void);
#endif

    SCOPIRA_EXPORT void next(uuid &out);

    // array/multi gen version of next()??
    // or just do some kind of +1 system?
};

#endif