Changeset 146

Timestamp:

1999-02-04T23:00:57+13:00 (25 years ago)

Author:

rjmcnab

Message:

Developed the idea of an "action" and having them define the cgi arguments
which they need and how those cgi arguments function.

Location:

trunk/gsdl/src/recpt

Files:

• action.cpp (modified) (2 diffs)
• action.h (modified) (1 diff)
• cgiargs.cpp (modified) (3 diffs)
• cgiargs.h (modified) (2 diffs)
• cgiwrapper.cpp (modified) (2 diffs)
• receptionist.cpp (modified) (4 diffs)
• receptionist.h (modified) (3 diffs)

trunk/gsdl/src/recpt/action.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.2  1999/02/04 10:00:53  rjmcnab
+
+   Developed the idea of an "action" and having them define the cgi arguments
+   which they need and how those cgi arguments function.
+
    Revision 1.1  1999/01/08 08:40:52  rjmcnab
 
@@ -22 +27 @@
  */
 
-static char *RCSID = "$Id$";
+
+#include "action.h"
+#include <assert.h>
 
 
-#include "action.h"
+action::action () {
+}
+
+action::~action () {
+}
+
+// returns the "a" argument value that will specify this action
+// this name should be short but does not have to be one character
+// long
+text_t action::get_action_name () {
+  return "nzdl";
+}
+
+// get_cgihead_info determines the cgi header information for
+// a set of cgi arguments. If response contains location then
+// response_data contains the redirect address. If reponse
+// contains content then reponse_data contains the content-type.
+// Note that images can now be produced by the receptionist.
+void action::get_cgihead_info (cgiargsclass &args, response_t &response,
+                   text_t &response_data, ostream &logout) {
+  response = location;
+  response_data = "http://www.nzdl.org";
+}
+  
+// returns false if there was an error which prevented the action
+// from outputing anything.
+bool action::do_action (cgiargsclass &args, outconvertclass &outconvert, 
+            ostream &textout, ostream &logout) {
+  return true;
+}
+
+// configure should be called once for each configuration line
+void action::configure (const text_tarray &cfgline) {
+}
 
 
 
+// theaction becomes the property of this class after addaction
+// therefore theaction should always be created using new but
+// not deleted after the call to addaction.
+void actionmapclass::addaction (action *theaction) {
+  // can't add a null action
+  assert (theaction != NULL);
+  if (theaction == NULL) return;
+  
+  // can't add an action with no name
+  assert (!(theaction->get_action_name()).empty());
+  if ((theaction->get_action_name()).empty()) return;
 
+  actionptr aptr;
+  aptr.a = theaction;
+  actionptrs[theaction->get_action_name()] = aptr;
+}
+
+// getaction will return NULL if the action could not be found
+action *actionmapclass::getaction (const text_t &key) {
+  iterator here = actionptrs.find (key);
+  if (here == actionptrs.end()) return NULL;
+  
+  return (*here).second.a;
+}

trunk/gsdl/src/recpt/action.h

@@ -14 +14 @@
 #define ACTION_H
 
+#include "gsdlconf.h"
+#include "text_t.h"
+#include "cgiargs.h"
 
+#if defined(GSDL_USE_OBJECTSPACE)
+#  include <ospace\std\iostream>
+#elif defined(GSDL_USE_IOS_H)
+#  include <iostream.h>
+#else
+#  include <iostream>
+#endif
+
+
+class action {
+protected:
+  cgiargsinfoclass argsinfo;
+
+public:
+  action ();
+  virtual ~action ();
+
+  // returns the "a" argument value that will specify this action
+  // this name should be short but does not have to be one character
+  // long
+  virtual text_t get_action_name ();
+
+  // response_t is used to inform the calling code what type of
+  // cgi header it should produce
+  // eventually this should reside in cgiutils.h
+  enum response_t {location, content};
+
+  // get_cgihead_info determines the cgi header information for
+  // a set of cgi arguments. If response contains location then
+  // response_data contains the redirect address. If reponse
+  // contains content then reponse_data contains the content-type.
+  // Note that images can now be produced by the receptionist.
+  virtual void get_cgihead_info (cgiargsclass &args, response_t &response,
+                 text_t &response_data, ostream &logout);
+  
+  // returns false if there was an error which prevented the action
+  // from outputing anything.
+  virtual bool do_action (cgiargsclass &args, outconvertclass &outconvert, 
+              ostream &textout, ostream &logout);
+
+  // configure should be called once for each configuration line
+  virtual void configure (const text_tarray &cfgline);
+
+  // getargsinfo should be called after all configuration files
+  // have been read
+  cgiargsinfoclass getargsinfo () {return argsinfo;};
+};
+
+
+// actionptr is used to keep track of pointers to actions
+// sub classes of action might not be the same size so
+// you probably don't want to treat a sub class as a standard
+// "action" class when it comes to copying etc -- anyone got
+// a better way to do this ????
+class actionptr {
+public:
+  action *a;
+
+  actionptr () {a=NULL;}
+  ~actionptr () {if (a!=NULL) delete a; a=NULL;}
+};
+
+typedef map<text_t, actionptr, lttext_t> actionptrmap;
+
+// contains a list of actions indexed by their name
+class actionmapclass {
+protected:
+  actionptrmap actionptrs;
+
+public:
+  // type support for actionptrmap
+  typedef actionptrmap::iterator iterator;
+  typedef actionptrmap::const_iterator const_iterator;
+  typedef actionptrmap::reference reference;
+  typedef actionptrmap::const_reference const_reference;
+  typedef actionptrmap::size_type size_type;
+
+  typedef actionptrmap::difference_type difference_type;
+  typedef actionptrmap::const_reverse_iterator const_reverse_iterator;
+  typedef actionptrmap::reverse_iterator reverse_iterator;
+  
+  // constructors
+  actionmapclass ();
+
+  // basic container support
+  iterator begin () {return actionptrs.begin();}
+  const_iterator begin () const {return actionptrs.begin();}
+  iterator end () {return actionptrs.end();}
+  const_iterator end () const {return actionptrs.end();}
+
+  void erase(iterator pos) {actionptrs.erase(pos);}
+  void erase(iterator first, iterator last) {actionptrs.erase(first, last);}
+  actionmapclass &operator=(const actionmapclass &x) {actionptrs=x.actionptrs;return *this;}
+
+  bool empty () const {return actionptrs.empty();}
+  size_type size() const {return actionptrs.size();}
+
+
+  // added functionality
+  void clear () {actionptrs.erase(actionptrs.begin(),actionptrs.end());}
+
+  // theaction becomes the property of this class after addaction
+  // therefore theaction should always be created using new but
+  // not deleted after the call to addaction.
+  void addaction (action *theaction);
+
+  // getaction will return NULL if the action could not be found
+  action *getaction (const text_t &key);
+};
 
 

trunk/gsdl/src/recpt/cgiargs.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.3  1999/02/04 10:00:54  rjmcnab
+
+   Developed the idea of an "action" and having them define the cgi arguments
+   which they need and how those cgi arguments function.
+
    Revision 1.2  1999/01/12 01:51:06  rjmcnab
 
@@ -32 +37 @@
   
 // constructors
-cgiargsclass::cgiargsclass ()
-{
+cgiargsclass::cgiargsclass () {
 }
 
@@ -110 +114 @@
 
 
+
+cgiarginfo::cgiarginfo () {
+  multiplechar = false;
+  defaultstatus = weak;
+}
+
+  
+// constructor
+cgiargsinfoclass::cgiargsinfoclass () {
+}
+
+// addarginfo will combine the information with the present
+// information. If name clashes were detected then the information
+// will be written to logout and addarginfo will return false. No
+// processing with the arguments should be done if this happens
+// as the results will be meaningless.
+bool cgiargsinfoclass::addarginfo (ostream &logout, const cgiarginfo &info) {
+  outconvertclass text_t2ascii;
+
+  cgiarginfo *orginfo = getarginfo (info.shortname);
+  if (orginfo == NULL) {
+    argsinfo[info.shortname] = info;
+    return true; // no clashes
+  }
+
+  if (orginfo->longname != info.longname) {
+    logout << text_t2ascii << "Error: cgi argument name clash for argument \""
+       << info.shortname << "\".\nOne long name was\n  \"" << orginfo->longname 
+       << "\"\nand the other was\n  \"" << info.longname << "\".\n\n";
+    return false; // found a clash
+  }
+
+  if (orginfo->multiplechar != info.multiplechar) {
+    logout << text_t2ascii << "Error: cgi argument \"" << info.shortname 
+       << "\" was given as being a single character option\n"
+       << "and a multiple character option.\n\n";
+    return false; // found a clash
+  }
+
+  if (!info.multiplechar && info.argdefault.size() > 1) {
+    logout << text_t2ascii << "Error: cgi argument \"" << info.shortname
+       << "\" was defined as being a single character option\n"
+       << "but a multiple character default was given.\n\n";
+  }
+
+  if (orginfo->defaultstatus > info.defaultstatus) {
+    return true;
+  }
+
+  orginfo->defaultstatus = info.defaultstatus;
+  orginfo->argdefault = info.argdefault;
+  return true;
+}
+
+bool cgiargsinfoclass::addarginfo (ostream &logout, const cgiargsinfoclass &info) {
+  const_iterator here = info.begin ();
+  const_iterator end = info.end ();
+
+  while (here != end) {
+    if (!addarginfo (logout, (*here).second)) return false;
+    here++;
+  }
+  
+  return true; // made it, no clashes
+}
+
+cgiarginfo *cgiargsinfoclass::getarginfo (const text_t &key) {
+  iterator here = argsinfo.find (key);
+  if (here == argsinfo.end()) return NULL;
+
+  return &((*here).second);
+}
+

trunk/gsdl/src/recpt/cgiargs.h

@@ -34 +34 @@
 
 
+
 typedef map<text_t, text_t, lttext_t> textmap;
 
-
+// cgiargsclass is used to store a particular set
+// of cgi arguments.
 class cgiargsclass
 {
@@ -90 +92 @@
 };
 
-
 // stream operators to print cgi arguments for debugging purposes
 ostream &operator<<(ostream &outs, const cgiargsclass &args);
 
 
+
+// cgiarginfo holds information relating to a cgi argument
+class cgiarginfo {
+public:
+  cgiarginfo ();
+
+  // shortname is the name used in cgi arguments
+  text_t shortname;
+
+  // longname is the name used when giving information 
+  // about the argument and to spot name duplication
+  text_t longname;
+
+  // multiplechar should be set to true if the value can be
+  // more than one character long
+  bool multiplechar;
+
+  // defaultstatus_t indicates how good the default is when different
+  // defaults are given for one argument. "weak" is a basic guess that doesn't
+  // hold much weight, "good" is a better guess, "config" was a default
+  // given in a configuration file, and "imperative" means it must not
+  // be overriden at any costs (unless there is another "imperative"...)
+  // Note: I assume that the comparison weak < good < config < imperative
+  // holds :-/
+  enum defaultstatus_t {weak, good, config, imperative};
+
+  defaultstatus_t defaultstatus;
+  text_t argdefault;   // a default value
+};
+
+
+typedef map<text_t, cgiarginfo, lttext_t> argsinfomap;
+
+// contains a list of cgi argument information
+class cgiargsinfoclass {
+protected:
+  argsinfomap argsinfo;
+
+public:
+  // type support for arginfomap
+  typedef argsinfomap::iterator iterator;
+  typedef argsinfomap::const_iterator const_iterator;
+  typedef argsinfomap::reference reference;
+  typedef argsinfomap::const_reference const_reference;
+  typedef argsinfomap::size_type size_type;
+  typedef argsinfomap::difference_type difference_type;
+  typedef argsinfomap::const_reverse_iterator const_reverse_iterator;
+  typedef argsinfomap::reverse_iterator reverse_iterator;
+  
+  // constructors
+  cgiargsinfoclass ();
+
+  // basic container support
+  iterator begin () {return argsinfo.begin();}
+  const_iterator begin () const {return argsinfo.begin();}
+  iterator end () {return argsinfo.end();}
+  const_iterator end () const {return argsinfo.end();}
+
+  void erase(iterator pos) {argsinfo.erase(pos);}
+  void erase(iterator first, iterator last) {argsinfo.erase(first, last);}
+  cgiargsinfoclass &operator=(const cgiargsinfoclass &x) {argsinfo=x.argsinfo;return *this;}
+
+  bool empty () const {return argsinfo.empty();}
+  size_type size() const {return argsinfo.size();}
+
+
+  // added functionality
+  void clear () {argsinfo.erase(argsinfo.begin(),argsinfo.end());}
+
+  // addarginfo will combine the information with the present
+  // information. If name clashes were detected then the information
+  // will be written to logout and addarginfo will return false. No
+  // processing with the arguments should be done if this happens
+  // as the results will be meaningless.
+  bool addarginfo (ostream &logout, const cgiarginfo &info);
+  bool addarginfo (ostream &logout, const cgiargsinfoclass &info);
+
+  cgiarginfo *getarginfo (const text_t &key);
+  cgiarginfo &operator[] (const text_t &key) {return argsinfo[key];}
+};
+
+
+
 #endif

trunk/gsdl/src/recpt/cgiwrapper.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.2  1999/02/04 10:00:56  rjmcnab
+
+   Developed the idea of an "action" and having them define the cgi arguments
+   which they need and how those cgi arguments function.
+
    Revision 1.1  1999/02/04 01:16:17  rjmcnab
 
@@ -223 +228 @@
   // initialise the library software
   ofstream initout (GSDL_GSDLHOME "/etc/initout.txt");
-  if (!recpt.init(initout)) {
+  if (!recpt.digest(initout)) {
     // an error occurred during the initialisation
     initout.close();

trunk/gsdl/src/recpt/receptionist.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.3  1999/02/04 10:00:56  rjmcnab
+
+   Developed the idea of an "action" and having them define the cgi arguments
+   which they need and how those cgi arguments function.
+
    Revision 1.2  1999/02/04 01:17:27  rjmcnab
 
@@ -73 +78 @@
 // meaningless output), instead an error page should be
 // produced by the calling code.
-bool receptionist::init (ostream &logout) {
+bool receptionist::digest (ostream &logout) {
   // redirect the error output to logout
-  disp.setlogout (&logout);
+  //  disp.setlogout (&logout);
 
   // set default values for the configuration file
-  cfg_info.defaultaction = "p";
-  cfg_info.defaultpage = "about";
-  cfg_info.defaultencoding = "w";
+  //  cfg_info.defaultaction = "p";
+  //  cfg_info.defaultpage = "about";
+  //  cfg_info.defaultencoding = "w";
 
   // read in the configuration files etc/collect.cfg and index/build.cfg
   // entries in build.cfg should override those in collect.cfg
-  filename = filename_cat (collectdir, "etc");
-  filename = filename_cat (filename, "collect.cfg");
-  cfg_read(filename);
+  //  filename = filename_cat (collectdir, "etc");
+  //  filename = filename_cat (filename, "collect.cfg");
+  //  cfg_read(filename);
 
   // load up the default macro files, the collection directory
   // is searched first for the file and then the main directory
-  text_t colmacrodir = filename_cat (collectdir, "macros");
-  text_t gsdlmacrodir = filename_cat (gsdlhome, "macros");
-  text_tarray::iterator arrhere = cfg_info.macrofiles.begin();
-  text_tarray::iterator arrend = cfg_info.macrofiles.end();
-  while (arrhere != arrend) {
-    filename = filename_cat (colmacrodir, *arrhere);
-    if (!file_exists (filename)) {
-      filename = filename_cat (gsdlmacrodir, *arrhere);
-    }
-    disp.loaddefaultmacros(filename);
-    arrhere++;
-  }
+  //  text_t colmacrodir = filename_cat (collectdir, "macros");
+  //  text_t gsdlmacrodir = filename_cat (gsdlhome, "macros");
+  //  text_tarray::iterator arrhere = cfg_info.macrofiles.begin();
+  //  text_tarray::iterator arrend = cfg_info.macrofiles.end();
+  //  while (arrhere != arrend) {
+  //    filename = filename_cat (colmacrodir, *arrhere);
+  //    if (!file_exists (filename)) {
+  //      filename = filename_cat (gsdlmacrodir, *arrhere);
+  //    }
+  //    disp.loaddefaultmacros(filename);
+  //    arrhere++;
+  //  }
 
-  srand(time(NULL));
+  //  srand(time(NULL));
 
-  utf8outconvert.set_rzws(1);
-  gboutconvert.set_rzws(1);
+  //  utf8outconvert.set_rzws(1);
+  //  gboutconvert.set_rzws(1);
 
-  return collect_init(collection);
+  //  return collect_init(collection);
+  return true;
 }
 
@@ -134 +140 @@
 // contains content then reponse_data contains the content-type.
 // Note that images can now be produced by the receptionist.
-void receptionist::get_cgihead_info (const cgiargsclass &args, response_t &response,
+void receptionist::get_cgihead_info (cgiargsclass &args, response_t &response,
                      text_t &response_data, ostream &logout) {
 }
@@ -140 +146 @@
 
 // produce the page content
-void receptionist::produce_content (const cgiargsclass &args, ostream &contentout,
+void receptionist::produce_content (cgiargsclass &args, ostream &contentout,
                     ostream &logout) {
 }

trunk/gsdl/src/recpt/receptionist.h

@@ -47 +47 @@
   void set_gwcgi (const text_t &thegwcgi);
 
-  // init should be called after setgsdhome has been called.
+  // digest should be called after setgsdhome has been called.
   // It returns true on success and false on failure. If false is
   // returned getpage should not be called (without producing
   // meaningless output), instead an error page should be
   // produced by the calling code.
-  bool init (ostream &logout);
+  bool digest (ostream &logout);
   
   // There are two ways to produce a page. You can either call parse_cgi_args,
@@ -73 +73 @@
   // response_t is used to inform the calling code what type of
   // cgi header it should produce
+  // eventually this should reside in cgiutils.h
   enum response_t {location, content};
 
@@ -80 +81 @@
   // contains content then reponse_data contains the content-type.
   // Note that images can now be produced by the receptionist.
-  void get_cgihead_info (const cgiargsclass &args, response_t &response,
+  void get_cgihead_info (cgiargsclass &args, response_t &response,
              text_t &response_data, ostream &logout);
 
   // produce the page content
-  void produce_content (const cgiargsclass &args, ostream &contentout,
+  void produce_content (cgiargsclass &args, ostream &contentout,
             ostream &logout);