refactor: extract grammar_base

include/abnf/grammar.h

@@ -74,36 +74,44 @@ inline bool operator==(rule const & lhs, rule const & rhs) {
   return lhs.rules == rhs.rules;
 }
 
-class grammar {
+class grammar_base {
 public:
   using rule_store = std::map<std::string, rule, detail::iless>;
 
 private:
   struct satisfies_result;
 
-public:
-  grammar(std::string_view name, rule base_rule, rule_store rules = {})
-      : name_(name), base_rule_(std::move(base_rule)),
-        rules_(std::move(rules)) {}
+protected:
+  explicit grammar_base(rule_store rules) : rules_(std::move(rules)) {}
 
-  bool satisfies(std::string_view text) const;
+  satisfies_result satisfies(std::string_view & text, rule const & rule) const;
+  satisfies_result satisfies(std::string_view text, auto const & lit) const;
 
 private:
-  grammar() = default;
+  friend bool operator==(grammar_base const &, grammar_base const &) = default;
 
-  satisfies_result satisfies(std::string_view & text, rule const & rule) const;
-  satisfies_result satisfies(std::string_view text, auto const & lit) const;
+private:
+  static rule_store const s_default_rules_;
+  rule_store rules_;
+};
 
-  friend bool operator==(grammar const &, grammar const &) = default;
+class grammar : public grammar_base {
+public:
+  using rule_store = std::map<std::string, rule, detail::iless>;
+
+public:
+  grammar(std::string_view name, rule base_rule, rule_store rules = {})
+      : grammar_base(std::move(rules)), name_(name),
+        base_rule_(std::move(base_rule)) {}
+
+  bool satisfies(std::string_view text) const;
 
 private:
+  friend bool operator==(grammar const &, grammar const &) = default;
   friend std::ostream & operator<<(std::ostream &, grammar const &);
 
   std::string name_;
   rule base_rule_;
-  // TODO: Default Rules of ABNF
-  static rule_store const s_default_rules_;
-  rule_store rules_;
 };
 
 rule::rule(rule_part_like auto && part)

src/grammar.cxx

@@ -5,7 +5,7 @@
 
 #include <abnf/literals.h>
 
-struct abnf::grammar::satisfies_result {
+struct abnf::grammar_base::satisfies_result {
   satisfies_result(size_t read) : read(read), valid(true) {}
   satisfies_result(bool valid) : valid(valid) {}
 
@@ -24,7 +24,7 @@ struct abnf::grammar::satisfies_result {
 namespace abnf {
 using namespace abnf::literals;
 
-grammar::rule_store const grammar::s_default_rules_{
+grammar_base::rule_store const grammar_base::s_default_rules_{
     {"ALPHA", "%x41-5A"_range / "%x61-7A"_range},
     {"DIGIT", "%x30-39"_range},
     {"HEXDIG", "DIGIT"_ref / "%x41-46"_range / "%x61-66"_range},
@@ -63,15 +63,15 @@ reference::reference(std::string_view ref) {
 }
 
 template <>
-auto grammar::satisfies(std::string_view text, literal const & lit) const
+auto grammar_base::satisfies(std::string_view text, literal const & lit) const
     -> satisfies_result {
   if (text.starts_with(lit.value)) { return lit.value.size(); }
   return false;
 }
 
 template <>
-auto grammar::satisfies(std::string_view text, char_range const & rng) const
-    -> satisfies_result {
+auto grammar_base::satisfies(std::string_view text,
+                             char_range const & rng) const -> satisfies_result {
   if (code_point cp(text); cp >= rng.first && cp <= rng.last) {
     return cp.width();
   }
@@ -79,7 +79,7 @@ auto grammar::satisfies(std::string_view text, char_range const & rng) const
 }
 
 template <>
-auto grammar::satisfies(std::string_view text, reference const & ref) const
+auto grammar_base::satisfies(std::string_view text, reference const & ref) const
     -> satisfies_result {
   if (auto it = s_default_rules_.find(ref.value);
       it != s_default_rules_.end()) {
@@ -89,7 +89,7 @@ auto grammar::satisfies(std::string_view text, reference const & ref) const
 }
 
 template <>
-auto grammar::satisfies(std::string_view text, repeated const & rep) const
+auto grammar_base::satisfies(std::string_view text, repeated const & rep) const
     -> satisfies_result {
   size_t count = 0;
   satisfies_result result{true};
@@ -101,7 +101,7 @@ auto grammar::satisfies(std::string_view text, repeated const & rep) const
 }
 
 template <>
-auto grammar::satisfies(std::string_view text, one_of const & one_of) const
+auto grammar_base::satisfies(std::string_view text, one_of const & one_of) const
     -> satisfies_result {
   for (rule const & r : one_of.rules) {
     std::string_view tmp = text;
@@ -110,7 +110,7 @@ auto grammar::satisfies(std::string_view text, one_of const & one_of) const
   return false;
 }
 
-auto grammar::satisfies(std::string_view & text, rule const & rule) const
+auto grammar_base::satisfies(std::string_view & text, rule const & rule) const
     -> satisfies_result {
   auto visitor = [this, &text](auto const & part) {
     return satisfies(text, part);
@@ -130,6 +130,6 @@ auto grammar::satisfies(std::string_view & text, rule const & rule) const
 }
 
 bool grammar::satisfies(std::string_view text) const {
-  return satisfies(text, base_rule_).valid;
+  return grammar_base::satisfies(text, base_rule_).valid;
 }
 }

src/parser.cxx

@@ -108,7 +108,7 @@ static std::string parse_rule(std::istream & in, std::string const & name,
 
 static auto parse_impl(std::istream & in) {
   std::string first_rule;
-  grammar::rule_store store;
+  grammar_base::rule_store store;
 
   std::string name;
   rule rule;