Domain.hpp

   1 #ifndef DOMAIN_DOT_HPP
   2 #define DOMAIN_DOT_HPP
   3
   4 #include "IP.hpp"
   5
   6 #include <compare>
   7 #include <iostream>
   8 #include <string>
   9 #include <string_view>
  10
  11 #include "iequal.hpp"
  12
  13 // The 'domain' part of an email address: DNS domain, or IP address, or address
  14 // literal, or empty.
  15
  16 class Domain {
  17 public:
  18   Domain() = default;
  19
  20   inline explicit Domain(std::string_view dom);
  21
  22   inline static bool
  23   validate(std::string_view domain, std::string& msg, Domain& dom);
  24
  25   inline void clear();
  26
  27   inline bool empty() const;
  28
  29   inline bool operator==(Domain const& rhs) const;
  30   inline auto operator<=>(Domain const& rhs) const;
  31
  32   inline bool is_address_literal() const;
  33   inline bool is_unicode() const;
  34
  35   inline std::string const& ascii() const;
  36   inline std::string const& utf8() const;
  37
  38 private:
  39   bool set_(std::string_view dom, bool should_throw, std::string& msg);
  40
  41   std::string ascii_; // A-labels
  42   std::string utf8_;  // U-labels, or empty
  43
  44   bool is_address_literal_{false};
  45 };
  46
  47 Domain::Domain(std::string_view dom)
  48 {
  49   std::string msg;
  50   set_(dom, true /* throw */, msg);
  51 }
  52
  53 bool Domain::validate(std::string_view domain, std::string& msg, Domain& dom)
  54 {
  55   return dom.set_(domain, false /* don't throw */, msg);
  56 }
  57
  58 void Domain::clear()
  59 {
  60   ascii_.clear();
  61   utf8_.clear();
  62   is_address_literal_ = false;
  63 }
  64
  65 bool Domain::empty() const { return ascii_.empty(); }
  66
  67 bool Domain::operator==(Domain const& rhs) const
  68 {
  69   return ascii_ == rhs.ascii_;
  70 }
  71
  72 auto Domain::operator<=>(const Domain& rhs) const
  73 {
  74   return ascii_ <=> rhs.ascii_;
  75 }
  76
  77 bool Domain::is_address_literal() const { return is_address_literal_; }
  78 bool Domain::is_unicode() const
  79 {
  80   return (!utf8().empty()) && (utf8() != ascii());
  81 }
  82
  83 std::string const& Domain::ascii() const { return ascii_; }
  84 std::string const& Domain::utf8() const
  85 {
  86   return utf8_.empty() ? ascii_ : utf8_;
  87 }
  88
  89 inline std::ostream& operator<<(std::ostream& os, Domain const& dom)
  90 {
  91   if (dom.is_unicode())
  92     return os << '{' << dom.ascii() << ',' << dom.utf8() << '}';
  93   return os << dom.ascii();
  94 }
  95
  96 namespace domain {
  97 bool is_fully_qualified(Domain const& dom, std::string& msg);
  98 }
  99
 100 namespace std {
 101 template <>
 102 struct hash<Domain> {
 103   std::size_t operator()(Domain const& k) const
 104   {
 105     return hash<std::string>()(k.ascii());
 106   }
 107 };
 108 } // namespace std
 109
 110 #endif // DOMAIN_DOT_HPP