commit a5a5ef6dbaa4ce7d0ba457a7df5e18327ff65b2b
author Shinichiro Hamaji <shinichiro.hamaji@gmail.com> Fri Jul 31 14:45:41 2015 +0900
committer Shinichiro Hamaji <shinichiro.hamaji@gmail.com> Fri Jul 31 14:45:41 2015 +0900
tree 429277898a6513d3d96f868513f7ab13f240483c
parent ed883ef3391d7a4039acb4ed4730522add98d750

[C++] Expose FindCommand struct

find.cc

diff --git a/find.cc b/find.cc
index b39f0b8..8e36778 100644
--- a/find.cc
+++ b/find.cc
@@ -34,17 +34,17 @@
 #include "strutil.h"
 #include "timeutil.h"
 
-namespace {
-
-class Cond {
+class FindCond {
  public:
-  virtual ~Cond() = default;
+  virtual ~FindCond() = default;
   virtual bool IsTrue(const string& name, unsigned char type) const = 0;
  protected:
-  Cond() = default;
+  FindCond() = default;
 };
 
-class NameCond : public Cond {
+namespace {
+
+class NameCond : public FindCond {
  public:
   explicit NameCond(const string& n)
       : name_(n) {
@@ -56,7 +56,7 @@
   string name_;
 };
 
-class TypeCond : public Cond {
+class TypeCond : public FindCond {
  public:
   explicit TypeCond(unsigned char t)
       : type_(t) {
@@ -68,21 +68,21 @@
   unsigned char type_;
 };
 
-class NotCond : public Cond {
+class NotCond : public FindCond {
  public:
-  NotCond(Cond* c)
+  NotCond(FindCond* c)
       : c_(c) {
   }
   virtual bool IsTrue(const string& name, unsigned char type) const {
     return !c_->IsTrue(name, type);
   }
  private:
-  unique_ptr<Cond> c_;
+  unique_ptr<FindCond> c_;
 };
 
-class AndCond : public Cond {
+class AndCond : public FindCond {
  public:
-  AndCond(Cond* c1, Cond* c2)
+  AndCond(FindCond* c1, FindCond* c2)
       : c1_(c1), c2_(c2) {
   }
   virtual bool IsTrue(const string& name, unsigned char type) const {
@@ -91,12 +91,12 @@
     return false;
   }
  private:
-  unique_ptr<Cond> c1_, c2_;
+  unique_ptr<FindCond> c1_, c2_;
 };
 
-class OrCond : public Cond {
+class OrCond : public FindCond {
  public:
-  OrCond(Cond* c1, Cond* c2)
+  OrCond(FindCond* c1, FindCond* c2)
       : c1_(c1), c2_(c2) {
   }
   virtual bool IsTrue(const string& name, unsigned char type) const {
@@ -105,23 +105,7 @@
     return true;
   }
  private:
-  unique_ptr<Cond> c1_, c2_;
-};
-
-struct FindCommand {
-  FindCommand()
-      : follows_symlinks(false), depth(INT_MAX) {
-  }
-  ~FindCommand() {
-  }
-
-  StringPiece chdir;
-  StringPiece testdir;
-  vector<StringPiece> finddirs;
-  bool follows_symlinks;
-  unique_ptr<Cond> print_cond;
-  unique_ptr<Cond> prune_cond;
-  int depth;
+  unique_ptr<FindCond> c1_, c2_;
 };
 
 class DirentNode {
@@ -440,18 +424,18 @@
       return true;
     }
 
-    Cond* ParseFact(StringPiece tok) {
+    FindCond* ParseFact(StringPiece tok) {
       if (tok == "-not" || tok == "\\!") {
         if (!GetNextToken(&tok) || tok.empty())
           return NULL;
-        unique_ptr<Cond> c(ParseFact(tok));
+        unique_ptr<FindCond> c(ParseFact(tok));
         if (!c.get())
           return NULL;
         return new NotCond(c.release());
       } else if (tok == "\\(") {
         if (!GetNextToken(&tok) || tok.empty())
           return NULL;
-        unique_ptr<Cond> c(ParseExpr(tok));
+        unique_ptr<FindCond> c(ParseExpr(tok));
         if (!GetNextToken(&tok) || tok != "\\)") {
           return NULL;
         }
@@ -487,8 +471,8 @@
       }
     }
 
-    Cond* ParseTerm(StringPiece tok) {
-      unique_ptr<Cond> c(ParseFact(tok));
+    FindCond* ParseTerm(StringPiece tok) {
+      unique_ptr<FindCond> c(ParseFact(tok));
       if (!c.get())
         return NULL;
       while (true) {
@@ -500,7 +484,7 @@
         }
         if (!GetNextToken(&tok) || tok.empty())
           return NULL;
-        unique_ptr<Cond> r(ParseFact(tok));
+        unique_ptr<FindCond> r(ParseFact(tok));
         if (!r.get()) {
           return NULL;
         }
@@ -508,8 +492,8 @@
       }
     }
 
-    Cond* ParseExpr(StringPiece tok) {
-      unique_ptr<Cond> c(ParseTerm(tok));
+    FindCond* ParseExpr(StringPiece tok) {
+      unique_ptr<FindCond> c(ParseTerm(tok));
       if (!c.get())
         return NULL;
       while (true) {
@@ -521,7 +505,7 @@
         }
         if (!GetNextToken(&tok) || tok.empty())
           return NULL;
-        unique_ptr<Cond> r(ParseTerm(tok));
+        unique_ptr<FindCond> r(ParseTerm(tok));
         if (!r.get()) {
           return NULL;
         }
@@ -539,7 +523,7 @@
     // <name> ::= '-name' NAME
     // <type> ::= '-type' TYPE
     // <maxdepth> ::= '-maxdepth' MAXDEPTH
-    Cond* ParseFindCond(StringPiece tok) {
+    FindCond* ParseFindCond(StringPiece tok) {
       return ParseExpr(tok);
     }
 
@@ -577,7 +561,7 @@
         } else if (tok[0] == '-' || tok == "\\(") {
           if (fc_->print_cond.get())
             return false;
-          Cond* c = ParseFindCond(tok);
+          FindCond* c = ParseFindCond(tok);
           if (!c)
             return false;
           fc_->print_cond.reset(c);
@@ -699,6 +683,10 @@
 
 }  // namespace
 
+FindCommand::FindCommand()
+    : follows_symlinks(false), depth(INT_MAX) {
+}
+
 FindEmulator* FindEmulator::Get() {
   return g_instance;
 }

find.h

diff --git a/find.h b/find.h
index 3ec1a4d..420576c 100644
--- a/find.h
+++ b/find.h
@@ -15,10 +15,29 @@
 #ifndef FIND_H_
 #define FIND_H_
 
+#include <memory>
 #include <string>
+#include <vector>
+
+#include "string_piece.h"
 
 using namespace std;
 
+class FindCond;
+
+struct FindCommand {
+  FindCommand();
+  ~FindCommand() = default;
+
+  StringPiece chdir;
+  StringPiece testdir;
+  vector<StringPiece> finddirs;
+  bool follows_symlinks;
+  unique_ptr<FindCond> print_cond;
+  unique_ptr<FindCond> prune_cond;
+  int depth;
+};
+
 class FindEmulator {
  public:
   virtual ~FindEmulator() = default;