Fix stream operator on rules and items

src/lr/item.cpp

@@ -1,8 +1,10 @@
 #include "item.h"
 
+using namespace std;
+
 namespace tree_sitter {
     namespace lr {
-        Item::Item(const std::string &rule_name, rules::rule_ptr rule, int consumed_sym_count) :
+        Item::Item(const std::string &rule_name, const rules::rule_ptr rule, int consumed_sym_count) :
             rule_name(rule_name),
             rule(rule),
             consumed_sym_count(consumed_sym_count) {};
@@ -12,5 +14,31 @@ namespace tree_sitter {
                 return item_ptr(new Item(rule_name, to_rule, consumed_sym_count + 1));
             });
         };
+        
+        vector<rules::rule_ptr> Item::next_symbols() const {
+            vector<rules::rule_ptr> result;
+            for (auto pair : rule->transitions())
+                result.push_back(pair.second);
+            return result;
+        }
+    
+        bool Item::operator==(const Item &other) const {
+            return (
+                other.rule_name == rule_name &&
+                other.rule == rule &&
+                other.consumed_sym_count == consumed_sym_count);
+        }
+        
+        std::ostream& operator<<(ostream &stream, const Item &item) {
+            stream <<
+                string("(item '") <<
+                item.rule_name <<
+                string("' ") <<
+                *item.rule <<
+                string(")");
+            return stream;
+        }
     }
-}
+}
+
+

src/lr/item.h

@@ -9,16 +9,20 @@ namespace tree_sitter {
     namespace lr {
         class Item {
         public:
-            Item(const std::string &rule_name, rules::rule_ptr rule, int consumed_sym_count);
+            Item(const std::string &rule_name, const rules::rule_ptr rule, int consumed_sym_count);
             TransitionMap<Item> transitions() const;
-        private:
-            std::string rule_name;
-            rules::rule_ptr rule;
-            int consumed_sym_count;
+            std::vector<rules::rule_ptr> next_symbols() const;
+            bool operator==(const Item &other) const;
+
+            const std::string rule_name;
+            const rules::rule_ptr rule;
+            const int consumed_sym_count;
         };
         
         typedef std::shared_ptr<Item> item_ptr;
+        std::ostream& operator<<(std::ostream &stream, const Item &item);
     }
 }
 
-#endif
+
+#endif

src/rules/rule.cpp

@@ -1,7 +1,11 @@
 #include "rule.h"
 
-std::ostream& operator<<(std::ostream& stream, const tree_sitter::rules::Rule &rule)
-{
-    stream << rule.to_string();
-    return stream;
+namespace tree_sitter {
+    namespace rules {
+        std::ostream& operator<<(std::ostream& stream, const Rule &rule)
+        {
+            stream << rule.to_string();
+            return stream;
+        }
+    }
 }

src/rules/rule.h

@@ -15,9 +15,9 @@ namespace tree_sitter {
         };
         
         typedef std::shared_ptr<const Rule> rule_ptr;
+        std::ostream& operator<<(std::ostream& stream, const Rule &rule);
     }
 }
 
-std::ostream& operator<<(std::ostream& stream, const tree_sitter::rules::Rule &rule);
 
 #endif