164 lines
3.8 KiB
C++
164 lines
3.8 KiB
C++
#ifndef ENTRYID_H_
|
|
#define ENTRYID_H_
|
|
|
|
#include <common/storage/Metadata.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <exception>
|
|
#include <string>
|
|
|
|
#include <boost/tuple/tuple.hpp>
|
|
#include <boost/tuple/tuple_comparison.hpp>
|
|
|
|
namespace db {
|
|
|
|
struct EntryID {
|
|
unsigned sequence;
|
|
unsigned timestamp;
|
|
unsigned nodeID;
|
|
|
|
// required for queries, since they use boost::tuple to avoid writing out huge comparison
|
|
// operators
|
|
EntryID()
|
|
: sequence(0), timestamp(0), nodeID(0)
|
|
{}
|
|
|
|
EntryID(unsigned sequence, unsigned timestamp, unsigned nodeID)
|
|
: sequence(sequence), timestamp(timestamp), nodeID(nodeID)
|
|
{
|
|
if(nodeID == 0 && (timestamp != 0 || sequence > 3) )
|
|
throw std::exception();
|
|
}
|
|
|
|
bool isSpecial() const { return nodeID == 0; }
|
|
|
|
bool operator<(const EntryID& other) const
|
|
{
|
|
return boost::make_tuple(sequence, timestamp, nodeID)
|
|
< boost::make_tuple(other.sequence, other.timestamp, other.nodeID);
|
|
}
|
|
|
|
bool operator==(const EntryID& other) const
|
|
{
|
|
return this->sequence == other.sequence
|
|
&& this->timestamp == other.timestamp
|
|
&& this->nodeID == other.nodeID;
|
|
}
|
|
|
|
bool operator!=(const EntryID& other) const
|
|
{
|
|
return !(*this == other);
|
|
}
|
|
|
|
bool isDisposalDir() const
|
|
{
|
|
return *this == disposal() || *this == mdisposal();
|
|
}
|
|
|
|
bool isRootDir() const
|
|
{
|
|
return *this == root();
|
|
}
|
|
|
|
std::string str() const
|
|
{
|
|
if(isSpecial() )
|
|
{
|
|
if(*this == anchor() )
|
|
return "";
|
|
|
|
if(*this == root() )
|
|
return META_ROOTDIR_ID_STR;
|
|
|
|
if(*this == disposal() )
|
|
return META_DISPOSALDIR_ID_STR;
|
|
|
|
if(*this == mdisposal())
|
|
return META_MIRRORDISPOSALDIR_ID_STR;
|
|
|
|
throw std::exception();
|
|
}
|
|
|
|
char buffer[3*8 + 2 + 1];
|
|
sprintf(buffer, "%X-%X-%X", sequence, timestamp, nodeID);
|
|
return buffer;
|
|
}
|
|
|
|
static EntryID anchor() { return EntryID(0, 0, 0); }
|
|
static EntryID root() { return EntryID(1, 0, 0); }
|
|
static EntryID disposal() { return EntryID(2, 0, 0); }
|
|
static EntryID mdisposal() { return EntryID(3, 0, 0); }
|
|
|
|
static EntryID fromStr(const std::string& str)
|
|
{
|
|
auto pair = tryFromStr(str);
|
|
if (!pair.first)
|
|
throw std::exception();
|
|
|
|
return pair.second;
|
|
}
|
|
|
|
static std::pair<bool, EntryID> tryFromStr(const std::string& str)
|
|
{
|
|
if (str.empty())
|
|
return {true, anchor()};
|
|
|
|
if (str == META_ROOTDIR_ID_STR)
|
|
return {true, root()};
|
|
|
|
if (str == META_DISPOSALDIR_ID_STR)
|
|
return {true, disposal()};
|
|
|
|
if (str == META_MIRRORDISPOSALDIR_ID_STR)
|
|
return {true, mdisposal()};
|
|
|
|
std::string::size_type sep1;
|
|
std::string::size_type sep2;
|
|
|
|
sep1 = str.find('-');
|
|
sep2 = str.find('-', sep1 + 1);
|
|
|
|
if (sep1 == str.npos || sep2 == str.npos)
|
|
return {false, {}};
|
|
|
|
std::string seqStr = str.substr(0, sep1);
|
|
std::string tsStr = str.substr(sep1 + 1, sep2 - (sep1 + 1));
|
|
std::string nodeStr = str.substr(sep2 + 1);
|
|
|
|
if (seqStr.empty() || tsStr.empty() || nodeStr.empty() ||
|
|
seqStr.size() > 8 || tsStr.size() > 8 || nodeStr.size() > 8)
|
|
return {false, {}};
|
|
|
|
struct
|
|
{
|
|
static bool notHex(char c)
|
|
{
|
|
return !std::isxdigit(c);
|
|
}
|
|
|
|
bool operator()(const std::string& str) const
|
|
{
|
|
return std::count_if(str.begin(), str.end(), notHex) == 0;
|
|
}
|
|
} onlyHex;
|
|
|
|
if (!onlyHex(seqStr) || !onlyHex(tsStr) || !onlyHex(nodeStr) )
|
|
return {false, {}};
|
|
|
|
unsigned seq;
|
|
unsigned ts;
|
|
unsigned node;
|
|
|
|
std::sscanf(seqStr.c_str(), "%x", &seq);
|
|
std::sscanf(tsStr.c_str(), "%x", &ts);
|
|
std::sscanf(nodeStr.c_str(), "%x", &node);
|
|
|
|
return {true, EntryID(seq, ts, node)};
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|