New upstream version 8.1.0

fsck/source/database/EntryID.h

@@ -0,0 +1,163 @@
+#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