OpenShot Library | libopenshot-audio  0.2.0
juce_Uuid.cpp
1 /*
2  ==============================================================================
3 
4  This file is part of the JUCE library.
5  Copyright (c) 2017 - ROLI Ltd.
6 
7  JUCE is an open source library subject to commercial or open-source
8  licensing.
9 
10  The code included in this file is provided under the terms of the ISC license
11  http://www.isc.org/downloads/software-support-policy/isc-license. Permission
12  To use, copy, modify, and/or distribute this software for any purpose with or
13  without fee is hereby granted provided that the above copyright notice and
14  this permission notice appear in all copies.
15 
16  JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
17  EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
18  DISCLAIMED.
19 
20  ==============================================================================
21 */
22 
23 namespace juce
24 {
25 
27 {
28  Random r;
29 
30  for (size_t i = 0; i < sizeof (uuid); ++i)
31  uuid[i] = (uint8) (r.nextInt (256));
32 
33  // To make it RFC 4122 compliant, need to force a few bits...
34  uuid[6] = (uuid[6] & 0x0f) | 0x40;
35  uuid[8] = (uuid[8] & 0x3f) | 0x80;
36 }
37 
38 Uuid::~Uuid() noexcept {}
39 
40 Uuid::Uuid (const Uuid& other) noexcept
41 {
42  memcpy (uuid, other.uuid, sizeof (uuid));
43 }
44 
45 Uuid& Uuid::operator= (const Uuid& other) noexcept
46 {
47  memcpy (uuid, other.uuid, sizeof (uuid));
48  return *this;
49 }
50 
51 bool Uuid::operator== (const Uuid& other) const noexcept { return memcmp (uuid, other.uuid, sizeof (uuid)) == 0; }
52 bool Uuid::operator!= (const Uuid& other) const noexcept { return ! operator== (other); }
53 
54 bool Uuid::operator< (const Uuid& other) const noexcept { return compare (other) < 0; }
55 bool Uuid::operator> (const Uuid& other) const noexcept { return compare (other) > 0; }
56 bool Uuid::operator<= (const Uuid& other) const noexcept { return compare (other) <= 0; }
57 bool Uuid::operator>= (const Uuid& other) const noexcept { return compare (other) >= 0; }
58 
59 int Uuid::compare (Uuid other) const noexcept
60 {
61  for (size_t i = 0; i < sizeof (uuid); ++i)
62  if (int diff = uuid[i] - (int) other.uuid[i])
63  return diff > 0 ? 1 : -1;
64 
65  return 0;
66 }
67 
68 Uuid Uuid::null() noexcept
69 {
70  return Uuid ((const uint8*) nullptr);
71 }
72 
73 bool Uuid::isNull() const noexcept
74 {
75  for (auto i : uuid)
76  if (i != 0)
77  return false;
78 
79  return true;
80 }
81 
82 String Uuid::getHexRegion (int start, int length) const
83 {
84  return String::toHexString (uuid + start, length, 0);
85 }
86 
88 {
89  return getHexRegion (0, 16);
90 }
91 
93 {
94  return getHexRegion (0, 4)
95  + "-" + getHexRegion (4, 2)
96  + "-" + getHexRegion (6, 2)
97  + "-" + getHexRegion (8, 2)
98  + "-" + getHexRegion (10, 6);
99 }
100 
101 Uuid::Uuid (const String& uuidString)
102 {
103  operator= (uuidString);
104 }
105 
106 Uuid& Uuid::operator= (const String& uuidString)
107 {
108  MemoryBlock mb;
109  mb.loadFromHexString (uuidString);
110  mb.ensureSize (sizeof (uuid), true);
111  mb.copyTo (uuid, 0, sizeof (uuid));
112  return *this;
113 }
114 
115 Uuid::Uuid (const uint8* const rawData) noexcept
116 {
117  operator= (rawData);
118 }
119 
120 Uuid& Uuid::operator= (const uint8* const rawData) noexcept
121 {
122  if (rawData != nullptr)
123  memcpy (uuid, rawData, sizeof (uuid));
124  else
125  zeromem (uuid, sizeof (uuid));
126 
127  return *this;
128 }
129 
130 uint32 Uuid::getTimeLow() const noexcept { return ByteOrder::bigEndianInt (uuid); }
131 uint16 Uuid::getTimeMid() const noexcept { return ByteOrder::bigEndianShort (uuid + 4); }
132 uint16 Uuid::getTimeHighAndVersion() const noexcept { return ByteOrder::bigEndianShort (uuid + 6); }
133 uint8 Uuid::getClockSeqAndReserved() const noexcept { return uuid[8]; }
134 uint8 Uuid::getClockSeqLow() const noexcept { return uuid[9]; }
135 uint64 Uuid::getNode() const noexcept { return (((uint64) ByteOrder::bigEndianShort (uuid + 10)) << 32) + ByteOrder::bigEndianInt (uuid + 12); }
136 
137 uint64 Uuid::hash() const noexcept
138 {
139  uint64 result = 0;
140 
141  for (auto n : uuid)
142  result = ((uint64) 101) * result + n;
143 
144  return result;
145 }
146 
147 } // namespace juce
juce::Uuid::isNull
bool isNull() const noexcept
Returns true if the ID is zero.
Definition: juce_Uuid.cpp:73
juce::Uuid::getTimeLow
uint32 getTimeLow() const noexcept
Returns the time-low section of the UUID.
Definition: juce_Uuid.cpp:130
juce::Uuid::~Uuid
~Uuid() noexcept
Destructor.
Definition: juce_Uuid.cpp:38
juce::Uuid::getNode
uint64 getNode() const noexcept
Returns the node section of the UUID.
Definition: juce_Uuid.cpp:135
juce::Uuid::toString
String toString() const
Returns a stringified version of this UUID.
Definition: juce_Uuid.cpp:87
juce::Uuid::Uuid
Uuid()
Creates a new unique ID, compliant with RFC 4122 version 4.
Definition: juce_Uuid.cpp:26
juce::Uuid::getTimeHighAndVersion
uint16 getTimeHighAndVersion() const noexcept
Returns the time-high-and-version section of the UUID.
Definition: juce_Uuid.cpp:132
juce::Uuid
A universally unique 128-bit identifier.
Definition: juce_Uuid.h:42
juce::Random::nextInt
int nextInt() noexcept
Returns the next random 32 bit integer.
Definition: juce_Random.cpp:78
juce::MemoryBlock::copyTo
void copyTo(void *destData, int sourceOffset, size_t numBytes) const noexcept
Copies data from this MemoryBlock to a memory address.
Definition: juce_MemoryBlock.cpp:239
juce::Uuid::operator=
Uuid & operator=(const Uuid &) noexcept
Copies another UUID.
Definition: juce_Uuid.cpp:45
juce::String::toHexString
static String toHexString(IntegerType number)
Returns a string representing this numeric value in hexadecimal.
Definition: juce_String.h:1055
juce::Random
A random number generator.
Definition: juce_Random.h:38
juce::Uuid::getClockSeqLow
uint8 getClockSeqLow() const noexcept
Returns the clock-seq-low section of the UUID.
Definition: juce_Uuid.cpp:134
juce::MemoryBlock::ensureSize
void ensureSize(const size_t minimumSize, bool initialiseNewSpaceToZero=false)
Increases the block's size only if it's smaller than a given size.
Definition: juce_MemoryBlock.cpp:148
juce::Uuid::hash
uint64 hash() const noexcept
Returns a hash of the UUID.
Definition: juce_Uuid.cpp:137
juce::Uuid::toDashedString
String toDashedString() const
Returns a stringified version of this UUID, separating it into sections with dashes.
Definition: juce_Uuid.cpp:92
juce::Uuid::getTimeMid
uint16 getTimeMid() const noexcept
Returns the time-mid section of the UUID.
Definition: juce_Uuid.cpp:131
juce::MemoryBlock::loadFromHexString
void loadFromHexString(StringRef sourceHexString)
Parses a string of hexadecimal numbers and writes this data into the memory block.
Definition: juce_MemoryBlock.cpp:316
juce::ByteOrder::bigEndianShort
static JUCE_CONSTEXPR uint16 bigEndianShort(const void *bytes) noexcept
Turns 2 bytes into a big-endian integer.
Definition: juce_ByteOrder.h:210
juce::String
The JUCE String class!
Definition: juce_String.h:42
juce::Uuid::getClockSeqAndReserved
uint8 getClockSeqAndReserved() const noexcept
Returns the clock-seq-and-reserved section of the UUID.
Definition: juce_Uuid.cpp:133
juce::ByteOrder::bigEndianInt
static JUCE_CONSTEXPR uint32 bigEndianInt(const void *bytes) noexcept
Turns 4 bytes into a big-endian integer.
Definition: juce_ByteOrder.h:211
juce::Uuid::null
static Uuid null() noexcept
Returns a null Uuid object.
Definition: juce_Uuid.cpp:68
juce::MemoryBlock
A class to hold a resizable block of raw data.
Definition: juce_MemoryBlock.h:36