uuid.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal
 
  This file is part of ANCH Framework.
 
  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  ANCH Framework is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include <iostream>
#include <iomanip>
#include <sstream>
#include <random>
#include <functional>
#include <atomic>
#include <mutex>
#include <map>
#include <cinttypes>
 
 
namespace anch {

  class UUID {
  public:
    enum class Version {
      NOT_SET = 0,

      MAC_ADDRESS = 1,

      DCE_SECURITY,

      MD5_HASH,

      RANDOM,

      SHA1_HASH,

      MAC_ADDRESS_R,

      RANDOM_TIME,

      EXP
    };
 
    // Attributes +
  public:
    static const uint64_t TIME_LOW_MASK = 0x00000000FFFFFFFF;

    static const uint64_t TIME_MID_MASK = 0x000000000000FFFF;

    static const uint64_t TIME_HIGH_MASK = 0x0000000000000FFF;

    static const uint64_t VERSION_MASK = 0x000000000000F000;

    static const uint32_t SEQ_LOW_MASK = 0x00FF;

    static const uint32_t SEQ_HIGH_MASK = 0x3F00;
 
  private:
    static std::mutex _mutex;

    static std::atomic_bool _seeded;

    static std::map<UUID::Version, std::function<UUID(const std::string&)>> _providers;

    uint32_t _lowTime;

    uint16_t _midTime;

    uint16_t _highTime;

    uint16_t _clockSeqLow;

    uint16_t _clockSeqHighRes;

    uint64_t _node;

    anch::UUID::Version _version;
    // Attributes -
 
 
    // Constructors +
  public:
    UUID();

    UUID(const UUID& uuid);

    UUID(UUID&& uuid);

    UUID(const std::string& uuid);

    UUID(uint32_t lowTime,
         uint16_t midTime,
         uint16_t highTime,
         uint16_t clockSeqLow,
         uint16_t clockSeqHighRes,
         uint64_t node,
         UUID::Version version);
    // Constructors -
 
    // Destructor +
  public:
    virtual ~UUID();
    // Destructor -
 
    // Methods +
  public:
    static void registerProvider(UUID::Version version, std::function<UUID(const std::string&)> provider);

    static UUID generateUUID(anch::UUID::Version version, const std::string& data = "");

    static UUID random();

    static UUID randomTime();

    static uint64_t getUtcTimestamp();

    static std::random_device& getRandomEngine();

    static std::uniform_int_distribution<uint16_t>& getDistSeq();

    static UUID parseUUID(const std::string& uuid);

    void parse(const std::string& uuid);

    std::string toString() const;
 
  private:
    static void registerRandomUUID();
    // Methods -
 
 
    // Operators +
  public:
    explicit operator std::string() const;

    bool operator ==(const UUID& uuid) const;

    bool operator !=(const UUID& uuid) const;

    UUID& operator =(const UUID& uuid);
    // Operators -
 
 
    // Accessors +
  public:
    uint32_t getLowTime() const;

    uint16_t getMidTime() const;

    uint16_t getHighTime() const;

    uint16_t getClockSeqLow() const;

    uint16_t getClockSeqHighRes() const;

    uint64_t getNode() const;

    anch::UUID::Version getVersion() const;
    // Accessors -
 
  };
 
}

template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& out, const anch::UUID& uuid);
 
#include "impl/uuid.hpp"