Author: miriam
Date: 2008-11-18 01:25:04 +0000 (Tue, 18 Nov 2008)
New Revision: 8430

Modified:
   software/gofind/gofind.cpp
   software/gofind/gui_cli.cpp
   software/gofind/guiplugin.h
Log:
Moved all CLI to plugin



Modified: software/gofind/gofind.cpp
===================================================================
--- software/gofind/gofind.cpp  2008-11-18 00:56:10 UTC (rev 8429)
+++ software/gofind/gofind.cpp  2008-11-18 01:25:04 UTC (rev 8430)
@@ -20,8 +20,6 @@
  */
 
 #include "common.h"
-#include "filter.h"
-#include "slre.h"
 #include "guiplugin.h"
 
 #include "Environment.h"
@@ -339,7 +337,6 @@
 
        GUIPlugIn *gui=gui_factory.factory->CreatePlugIn();
 
-       std::ostream &out = std::cout;
        gui->Comment(_("Starting system"));
 
        wibble::commandline::GamesOptions opts;
@@ -447,185 +444,7 @@
                */
 
                gui->Comment(_("System running"));
-
-               bool run = true;
-
-               struct slre_pattern pattern[5];
-               const char *pattern_text[5];
-               const char pattern_type[] = { 'h', 'l', 'g', 's', '\0' };
-               pattern_text[0] = "^\\s*(HELP|H)\\s*$";
-               pattern_text[1] = 
"^\\s*(LIST|L)\\s+(T|TYPES|I|INTERFACES|R|RESULTS)\\s*$";
-               pattern_text[2] = "^\\s*(GET|G)\\s+(\\S+)\\s*$";
-               pattern_text[3] = "^\\s*(SET|S)\\s+(\\S+)\\s*=\\s*(\\S+)\\s*$";
-               pattern_text[4] = NULL;
-
-               int j = 0;
-               while (pattern_text[j] != NULL)
-               {
-                       if (!slre_compile(&pattern[j], pattern_text[j]))
-                               std::cerr << _("Error compiling RE: ") << 
pattern[j].err_str << std::endl;
-                       j++;
-               }
-
-               while (run && !feof(stdin))
-               {
-                       char buffer[128];
-                       struct slre_capture captures[16];
-                       fgets(buffer, sizeof(buffer), stdin);
-                       if (*buffer == '#') continue;
-                       for (char *pnt = buffer; *pnt; pnt++)
-                       {
-                               if (*pnt=='\0' || *pnt=='\r' || *pnt=='\n')
-                               {
-                                       *pnt = '\0';
-                                       break;
-                               }
-                       }
-
-                       int match = -1;
-                       int j = 0;
-                       while (match == -1 && pattern_text[j] != NULL)
-                       {
-                               if (slre_match(pattern+j, buffer, 
strlen(buffer), captures))
-                               {
-                                       match = j;
-                                       out << "#match pattern " << match << 
std::endl;
-                               }
-                               j++;
-                       }
-                       if (match == -1)
-                               out << "#no pattern match " << match << 
std::endl;
-                       else switch (pattern_type[match])
-                       {
-                               case 'h':
-                               {
-                                       out << "# Commands:" << std::endl
-                                               << "# HELP" << std::endl
-                                               << "# LIST 
TYPES|INTERFACES|RESULTS" << std::endl
-                                               << "# GET <param>" << std::endl
-                                               << "# SET <param>=<value>" << 
std::endl;
-                               }
-                               break;
-                               case 'l':
-                               {
-                                       out << "#list: \"" << captures[2].ptr 
<<  "\"" << std::endl;
-                                       switch (captures[2].ptr[0])
-                                       {
-                                               case 'T': case 't':
-                                               {
-                                                       const set<Tag> types = 
engine.types();
-                                                       for 
(set<Tag>::const_iterator i = types.begin(); i != types.end(); ++i)
-                                                       {
-                                                               out << " " << 
i->shortDescription().c_str() << std::endl;
-                                                       }
-                                                       out << std::endl ;
-                                                       break;
-                                               }
-                                               case 'I': case 'i':
-                                               {
-                                                       const set<Tag> ifaces = 
engine.interfaces();
-                                                       for 
(set<Tag>::const_iterator i = ifaces.begin();
-                                                                       i != 
ifaces.end(); ++i)
-                                                       {
-                                                               out << " " << 
i->shortDescription().c_str() << std::endl;
-                                                       }
-                                                       out << std::endl ;
-                                                       break;
-                                               }
-                                               case 'R': case 'r':
-                                               {
-                                                       const 
std::vector<Result> res = engine.results();
-                                                       for 
(vector<Result>::const_iterator i = res.begin();
-                                                                       i != 
res.end(); ++i)
-                                                       {
-                                                               PackageRecord 
rec(engine.apt().rawRecord(i->name));
-       //                                                      char* userData 
= pkgString(rec.package());
-
-                                                               set<Tag> tags = 
engine.debtags().getTagsOfItem((const char *)rec.package().c_str());
-                                                               switch 
(pkgfilter.TagsValue(tags))
-                                                               {
-                                                                       case 
PackageFilter::Green:
-                                                                               
break;
-                                                                       case 
PackageFilter::Yellow:
-                                                                               
break;
-                                                                       case 
PackageFilter::Red:
-                                                                               
break;
-                                                                       case 
PackageFilter::Black:
-                                                                               
break;
-                                                                       default:
-                                                                               
break;
-                                                               }
-
-                                                               out << " "<<  
rec.package() + "\t" + rec.shortDescription();
-
-                                                               // Relevance is 
0 to 100
-                                                               // Popcon is a 
weird floating point number (to be improved)
-                                                               
//FIXMEaddToResults(rec.package() + " - " + rec.shortDescription(), 
i->relevance, i->popcon);
-                                                               if 
(engine.popcon().hasData() && i->popcon)
-                                                               {
-                                                                       out << 
"\tPOPCON=" << (int)rintf(log(i->popcon) * 100 / log(engine.popconLocalMax()));
-                                                               }
-
-                                                               if 
(engine.popcon().hasData() && i->relevance)
-                                                               {
-                                                                       out << 
"\tRELEVANCE=" << i->relevance;
-                                                               }
-
-                                                               out << 
std::endl ;
-                                                       }
-                                                       out << std::endl ;
-                                                       break;
-                                               }
-                                       }
-                               }
-                               break;
-                               case 'g':
-                               {
-                                       char name[sizeof(buffer)];
-                                       strncpy(name, captures[2].ptr, 
captures[2].len);
-                                       name[captures[2].len] = '\0';
-                                       out << "#get " << name << std::endl ;
-                                       if (memcmp(captures[2].ptr, 
"INSTALLED", 9) == 0)
-                                       {
-                                               switch 
(engine.getInstalledFilter())
-                                               {
-                                                       case Engine::INSTALLED:
-                                                               out << 
"installed=yes" << std::endl ;
-                                                               break;
-                                                       case 
Engine::NOTINSTALLED:
-                                                               out << 
"installed=no" << std::endl ;
-                                                               break;
-                                                       case Engine::ANY:
-                                                               out << 
"installed=any" << std::endl ;
-                                                               break;
-                                                       default:
-                                                               out << 
"#unknown installed value" << std::endl ;
-                                                               break;
-                                               }
-                                       }
-                                       if (memcmp(captures[2].ptr, "KEYWORD", 
7) == 0)
-                                       {
-                                               out << "keyword=\"" << 
engine.getKeywordFilter() << "\"" << std::endl ;
-                                       }
-                                       if (memcmp(captures[2].ptr, "TYPE", 4) 
== 0)
-                                       {
-                                               out << "type=?" << std::endl ;
-                                       }
-                                       if (memcmp(captures[2].ptr, 
"INTERFACE", 9) == 0)
-                                       {
-                                               out << "interface=?" << 
std::endl ;
-                                       }
-                               }
-                               break;
-                               case 'p':
-                               {
-                               }
-                               break;
-                               default:
-                               break;
-                       }
-               }
-
+               gui->Go(engine);
                gui->Comment(_("Stopping system"));
                delete gui;
                return 0;
@@ -657,7 +476,6 @@
                cerr << endl;
                return 1;
        }
-
 }
 #endif
 

Modified: software/gofind/gui_cli.cpp
===================================================================
--- software/gofind/gui_cli.cpp 2008-11-18 00:56:10 UTC (rev 8429)
+++ software/gofind/gui_cli.cpp 2008-11-18 01:25:04 UTC (rev 8430)
@@ -19,17 +19,41 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "common.h"
 #include "guiplugin.h"
 
+#include "filter.h"
 #include "slre.h"
 
 #include <typeinfo>
 #include <iostream>
 #include <string>
 
+#include <ept/apt/packagerecord.h>
+#include <wibble/regexp.h>
+#include <wibble/string.h>
+#include <xapian.h>
+
+#include <iostream>
+#include <cmath>
+
+#ifdef USE_GETTEXT
+#include <libintl.h>
+#include <locale.h>
+#else
+// Work-around until goplay is actually gettextised
+#define gettext(a) (a)
+#endif
+
 #include <stdarg.h>
 #include <string.h>
 
+using namespace std;
+using namespace ept;
+using namespace ept::debtags;
+using namespace ept::apt;
+using namespace ept::textsearch;
+
 class GUIPlugInCLI : public GUIPlugIn
 {
  public:
@@ -44,7 +68,7 @@
        }
 
        virtual void Comment(const char *szFormat, ...);
-       virtual void Go();
+       virtual bool Go(Engine &engine);
 };
 
 void GUIPlugInCLI::Comment(const char *szFormat, ...)
@@ -61,8 +85,187 @@
        std::cout << "##" << str << std::endl;
 }
 
-void GUIPlugInCLI::Go()
+bool GUIPlugInCLI::Go(Engine &engine)
 {
+       std::ostream &out = std::cout;
+
+       bool run = true;
+
+       struct slre_pattern pattern[5];
+       const char *pattern_text[5];
+       const char pattern_type[] = { 'h', 'l', 'g', 's', '\0' };
+       pattern_text[0] = "^\\s*(HELP|H)\\s*$";
+       pattern_text[1] = 
"^\\s*(LIST|L)\\s+(T|TYPES|I|INTERFACES|R|RESULTS)\\s*$";
+       pattern_text[2] = "^\\s*(GET|G)\\s+(\\S+)\\s*$";
+       pattern_text[3] = "^\\s*(SET|S)\\s+(\\S+)\\s*=\\s*(\\S+)\\s*$";
+       pattern_text[4] = NULL;
+
+       int j = 0;
+       while (pattern_text[j] != NULL)
+       {
+               if (!slre_compile(&pattern[j], pattern_text[j]))
+                       std::cerr << _("Error compiling RE: ") << 
pattern[j].err_str << std::endl;
+               j++;
+       }
+
+       while (run && !feof(stdin))
+       {
+               char buffer[128];
+               struct slre_capture captures[16];
+               fgets(buffer, sizeof(buffer), stdin);
+               if (*buffer == '#') continue;
+               for (char *pnt = buffer; *pnt; pnt++)
+               {
+                       if (*pnt=='\0' || *pnt=='\r' || *pnt=='\n')
+                       {
+                               *pnt = '\0';
+                               break;
+                       }
+               }
+
+               int match = -1;
+               int j = 0;
+               while (match == -1 && pattern_text[j] != NULL)
+               {
+                       if (slre_match(pattern+j, buffer, strlen(buffer), 
captures))
+                       {
+                               match = j;
+                               out << "#match pattern " << match << std::endl;
+                       }
+                       j++;
+               }
+               if (match == -1)
+                       out << "#no pattern match " << match << std::endl;
+               else switch (pattern_type[match])
+               {
+                       case 'h':
+                       {
+                               out << "# Commands:" << std::endl
+                                       << "# HELP" << std::endl
+                                       << "# LIST TYPES|INTERFACES|RESULTS" << 
std::endl
+                                       << "# GET <param>" << std::endl
+                                       << "# SET <param>=<value>" << std::endl;
+                       }
+                       break;
+                       case 'l':
+                       {
+                               out << "#list: \"" << captures[2].ptr <<  "\"" 
<< std::endl;
+                               switch (captures[2].ptr[0])
+                               {
+                                       case 'T': case 't':
+                                       {
+                                               const set<Tag> types = 
engine.types();
+                                               for (set<Tag>::const_iterator i 
= types.begin(); i != types.end(); ++i)
+                                               {
+                                                       out << " " << 
i->shortDescription().c_str() << std::endl;
+                                               }
+                                               out << std::endl ;
+                                               break;
+                                       }
+                                       case 'I': case 'i':
+                                       {
+                                               const set<Tag> ifaces = 
engine.interfaces();
+                                               for (set<Tag>::const_iterator i 
= ifaces.begin();
+                                                               i != 
ifaces.end(); ++i)
+                                               {
+                                                       out << " " << 
i->shortDescription().c_str() << std::endl;
+                                               }
+                                               out << std::endl ;
+                                               break;
+                                       }
+                                       case 'R': case 'r':
+                                       {
+                                               const std::vector<Result> res = 
engine.results();
+                                               for 
(vector<Result>::const_iterator i = res.begin();
+                                                               i != res.end(); 
++i)
+                                               {
+                                                       PackageRecord 
rec(engine.apt().rawRecord(i->name));
+//                                                     char* userData = 
pkgString(rec.package());
+                                                               set<Tag> tags = 
engine.debtags().getTagsOfItem((const char *)rec.package().c_str());
+                                                       switch 
(pkgfilter.TagsValue(tags))
+                                                       {
+                                                               case 
PackageFilter::Green:
+                                                                       break;
+                                                               case 
PackageFilter::Yellow:
+                                                                       break;
+                                                               case 
PackageFilter::Red:
+                                                                       break;
+                                                               case 
PackageFilter::Black:
+                                                                       break;
+                                                               default:
+                                                                       break;
+                                                       }
+
+                                                       out << " "<<  
rec.package() + "\t" + rec.shortDescription();
+
+                                                       // Relevance is 0 to 100
+                                                       // Popcon is a weird 
floating point number (to be improved)
+                                                       
//FIXMEaddToResults(rec.package() + " - " + rec.shortDescription(), 
i->relevance, i->popcon);
+                                                       if 
(engine.popcon().hasData() && i->popcon)
+                                                       {
+                                                               out << 
"\tPOPCON=" << (int)rintf(log(i->popcon) * 100 / log(engine.popconLocalMax()));
+                                                       }
+
+                                                       if 
(engine.popcon().hasData() && i->relevance)
+                                                       {
+                                                               out << 
"\tRELEVANCE=" << i->relevance;
+                                                       }
+
+                                                       out << std::endl ;
+                                               }
+                                               out << std::endl ;
+                                               break;
+                                       }
+                               }
+                       }
+                       break;
+                       case 'g':
+                       {
+                               char name[sizeof(buffer)];
+                               strncpy(name, captures[2].ptr, captures[2].len);
+                               name[captures[2].len] = '\0';
+                               out << "#get " << name << std::endl ;
+                               if (memcmp(captures[2].ptr, "INSTALLED", 9) == 
0)
+                               {
+                                       switch (engine.getInstalledFilter())
+                                       {
+                                               case Engine::INSTALLED:
+                                                       out << "installed=yes" 
<< std::endl ;
+                                                       break;
+                                               case Engine::NOTINSTALLED:
+                                                       out << "installed=no" 
<< std::endl ;
+                                                       break;
+                                               case Engine::ANY:
+                                                       out << "installed=any" 
<< std::endl ;
+                                                       break;
+                                               default:
+                                                       out << "#unknown 
installed value" << std::endl ;
+                                                       break;
+                                       }
+                               }
+                               if (memcmp(captures[2].ptr, "KEYWORD", 7) == 0)
+                               {
+                                       out << "keyword=\"" << 
engine.getKeywordFilter() << "\"" << std::endl ;
+                               }
+                               if (memcmp(captures[2].ptr, "TYPE", 4) == 0)
+                               {
+                                       out << "type=?" << std::endl ;
+                               }
+                               if (memcmp(captures[2].ptr, "INTERFACE", 9) == 
0)
+                               {
+                                       out << "interface=?" << std::endl ;
+                               }
+                       }
+                       break;
+                       case 'p':
+                       {
+                       }
+                       break;
+                       default:
+                       break;
+               }
+       }
+       return true;
 }
 
 class GUIPlugInCLIFactory : public GUIPlugInFactory

Modified: software/gofind/guiplugin.h
===================================================================
--- software/gofind/guiplugin.h 2008-11-18 00:56:10 UTC (rev 8429)
+++ software/gofind/guiplugin.h 2008-11-18 01:25:04 UTC (rev 8430)
@@ -23,6 +23,7 @@
 #define __PLUGIN_H
 
 #include "dll.h"
+#include "Engine.h"
 
 #include <iostream>
 
@@ -34,6 +35,8 @@
 //
 //
 
+using namespace ept;
+
 class GUIPlugIn
 {
  public:
@@ -42,7 +45,7 @@
        virtual ~GUIPlugIn();
 
        virtual void Comment(const char *szFormat, ...) = 0;
-       virtual void Go() = 0;
+       virtual bool Go(Engine &engine) = 0;
 };
 
 


_______________________________________________
Pkg-games-commits mailing list
[email protected]
http://lists.alioth.debian.org/mailman/listinfo/pkg-games-commits

Reply via email to