317 строки
8.4 KiB
C++
317 строки
8.4 KiB
C++
#include "CorrelationVector.hpp"
|
|
#include "utils/StringUtils.hpp" // for SplitString and AreAllCharactersWhitelisted
|
|
|
|
#include <vector>
|
|
#include <random>
|
|
#include <limits>
|
|
|
|
using std::string;
|
|
using std::mutex;
|
|
using std::vector;
|
|
|
|
namespace ARIASDK_NS_BEGIN
|
|
{
|
|
// Note: CV spec reserves the last character for the "!" suffix identifying sealed values.
|
|
// This effectively means we have one less character to use.
|
|
// (so 64 is reduced to 63 for v1 and 128 is reduced to 127 for v2).
|
|
|
|
const size_t CorrelationVector::c_maxCVLength_v1 = 63;
|
|
const size_t CorrelationVector::c_baseCVLength_v1 = 16;
|
|
|
|
const size_t CorrelationVector::c_maxCVLength_v2 = 127;
|
|
const size_t CorrelationVector::c_baseCVLength_v2 = 22;
|
|
|
|
const string CorrelationVector::s_base64CharSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
const string CorrelationVector::s_base10CharSet = "0123456789";
|
|
const string CorrelationVector::s_maxVectorElementValue = "4294967295";
|
|
|
|
CorrelationVector::CorrelationVector()
|
|
{
|
|
}
|
|
|
|
bool CorrelationVector::Initialize(int version)
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
if (version != 1 && version != 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_maxLength = (version == 1 ? c_maxCVLength_v1 : c_maxCVLength_v2);
|
|
size_t baseLength = (version == 1 ? c_baseCVLength_v1 : c_baseCVLength_v2);
|
|
|
|
m_currentVector = 0;
|
|
m_baseVector = InitializeInternal(baseLength);
|
|
m_isInitialized = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CorrelationVector::Uninitialize()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
m_currentVector = 0;
|
|
m_baseVector = "";
|
|
m_isInitialized = false;
|
|
}
|
|
|
|
bool CorrelationVector::IsInitialized()
|
|
{
|
|
return m_isInitialized;
|
|
}
|
|
|
|
string CorrelationVector::InitializeInternal(size_t baseLength)
|
|
{
|
|
string result = "";
|
|
std::random_device randomDevice;
|
|
std::uniform_int_distribution<int> base64Dist(0, 63);
|
|
|
|
|
|
for (size_t i = 0; i < baseLength; i++)
|
|
{
|
|
result += s_base64CharSet[base64Dist(randomDevice)];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
string CorrelationVector::GetNextValue()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
string result = GetValueInternal();
|
|
IncrementInternal();
|
|
|
|
return result;
|
|
}
|
|
|
|
string CorrelationVector::GetValue()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
return GetValueInternal();
|
|
}
|
|
|
|
string CorrelationVector::GetValueInternal()
|
|
{
|
|
if (m_isInitialized)
|
|
{
|
|
return m_baseVector + "." + std::to_string(m_currentVector);
|
|
}
|
|
return string { };
|
|
}
|
|
|
|
bool CorrelationVector::Extend()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
bool result = false;
|
|
|
|
if (CanExtendInternal())
|
|
{
|
|
m_baseVector = GetValueInternal();
|
|
m_currentVector = 0;
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool CorrelationVector::Increment()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
return IncrementInternal();
|
|
}
|
|
|
|
bool CorrelationVector::IncrementInternal()
|
|
{
|
|
bool result = false;
|
|
|
|
if (CanIncrementInternal())
|
|
{
|
|
m_currentVector++;
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool CorrelationVector::CanExtend()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
return CanExtendInternal();
|
|
}
|
|
|
|
bool CorrelationVector::CanIncrement()
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
return CanIncrementInternal();
|
|
}
|
|
|
|
bool CorrelationVector::CanExtendInternal()
|
|
{
|
|
if (!m_isInitialized)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// extending is appending ".0"
|
|
size_t newLength = GetLengthInternal(m_currentVector) + 2;
|
|
|
|
return (newLength <= m_maxLength);
|
|
}
|
|
|
|
bool CorrelationVector::CanIncrementInternal()
|
|
{
|
|
if (!m_isInitialized)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (m_currentVector == std::numeric_limits<unsigned int>::max())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// incrementing is adding one to m_currentVector
|
|
size_t newLength = GetLengthInternal(m_currentVector + 1);
|
|
|
|
return (newLength <= m_maxLength);
|
|
}
|
|
|
|
size_t CorrelationVector::GetLengthInternal(size_t vectorValue)
|
|
{
|
|
size_t vectorSize = GetDigitCount(vectorValue);
|
|
|
|
// base + "." + numeric representation of m_currentVector
|
|
return (m_baseVector.length() + 1 + vectorSize);
|
|
}
|
|
|
|
size_t CorrelationVector::GetDigitCount(size_t value)
|
|
{
|
|
size_t digitCount = 1;
|
|
|
|
while (value > 9)
|
|
{
|
|
value /= 10;
|
|
digitCount++;
|
|
}
|
|
|
|
return digitCount;
|
|
}
|
|
|
|
bool CorrelationVector::SetValue(const string& cv)
|
|
{
|
|
std::lock_guard<mutex> lock(m_lock);
|
|
|
|
// handle a special case: the last character could a "!", meaning that the vector is sealed for extension
|
|
if ((cv.length() == c_maxCVLength_v1 + 1 || cv.length() == c_maxCVLength_v2 + 1) && cv[cv.length() - 1] == '!')
|
|
{
|
|
|
|
}
|
|
|
|
vector<string> parts;
|
|
StringUtils::SplitString(cv, '.', parts);
|
|
|
|
if (parts.size() == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
size_t maxLength = 0;
|
|
for (size_t i = 0; i < parts.size(); i++)
|
|
{
|
|
// the first character group must be a base64 string or a certain length
|
|
if (i == 0)
|
|
{
|
|
if (parts[i].length() == c_baseCVLength_v1)
|
|
{
|
|
maxLength = c_maxCVLength_v1;
|
|
}
|
|
else if (parts[i].length() == c_baseCVLength_v2)
|
|
{
|
|
maxLength = c_maxCVLength_v2;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!StringUtils::AreAllCharactersWhitelisted(parts[i], s_base64CharSet))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// all other character groups must be non-empty, decimal digits
|
|
if (i != 0 && (parts[i].length() == 0 || !StringUtils::AreAllCharactersWhitelisted(parts[i], s_base10CharSet)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// validate the full cV length based on the known cV version
|
|
if (cv.length() > maxLength)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (parts.size() == 1)
|
|
{
|
|
// init with just the base value
|
|
m_baseVector = parts[0];
|
|
m_currentVector = 0;
|
|
}
|
|
else
|
|
{
|
|
size_t lastDot = cv.find_last_of(".");
|
|
bool parsingFailed = false;
|
|
string vectorString = cv.substr(lastDot + 1, string::npos);
|
|
// note: unsigned long is 32-bit on 32-bit arm devices
|
|
unsigned long currentVector = 0;
|
|
|
|
try
|
|
{
|
|
// do a manual string comparison before trying to parse the value to avoid throwing an exception
|
|
if (vectorString.length() == 0 ||
|
|
vectorString.length() > s_maxVectorElementValue.length() ||
|
|
(vectorString.length() == s_maxVectorElementValue.length() && vectorString > s_maxVectorElementValue))
|
|
{
|
|
parsingFailed = true;
|
|
}
|
|
else
|
|
{
|
|
currentVector = std::stoul(vectorString);
|
|
}
|
|
}
|
|
catch (std::invalid_argument&)
|
|
{
|
|
parsingFailed = true;
|
|
}
|
|
catch (std::out_of_range&)
|
|
{
|
|
parsingFailed = true;
|
|
}
|
|
|
|
if (parsingFailed || currentVector > std::numeric_limits<unsigned int>::max())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_baseVector = cv.substr(0, lastDot);
|
|
m_currentVector = currentVector;
|
|
}
|
|
|
|
m_maxLength = maxLength;
|
|
m_isInitialized = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
} ARIASDK_NS_END
|