Application.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2008 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/Application.h
 
#ifndef __Pulsar_Application_h
#define __Pulsar_Application_h
 
#include "Pulsar/Processor.h"
#include "CommandLine.h"
#include "Functor.h"
 
#include <algorithm>
 
namespace Pulsar {
 
  class Archive;
 
  class Application : public Reference::Able
  {
  public:
 
    Application (const std::string& name,
                 const std::string& description);
 
    virtual int main (int argc, char** argv);
 
    class Options;
 
    void add (Options*);
 
    std::string get_name () const;
 
    std::string get_description () const;
 
    bool get_verbose () const;
 
    virtual bool must_save ();
 
  protected:
 
    std::vector< Reference::To<Options> > options;
 
    virtual void add_options (CommandLine::Menu&) = 0;
 
    virtual void parse (int argc, char** argv);
 
    virtual void set_quiet ();
 
    virtual void set_verbose ();
 
    virtual void set_very_verbose ();
 
    virtual void setup ();
 
    template<typename Compare>
    void sort_archives (Compare c);
    
    virtual void run ();
 
    virtual Archive* load (const std::string& filename);
 
    virtual void process (Archive*) = 0;
 
    virtual bool do_finish () { return true; }
 
 
    virtual Archive* result () { return 0; }
 
    virtual void finish (Archive*);
 
    virtual void finalize ();
 
    bool has_manual;
 
    bool update_history;
 
    bool stow_script;
 
    // name of the application
    std::string name;
 
    // short description of the application
    std::string description;
 
    // revision information
    std::string version;
 
    // command line used to execute this program
    std::string command;
 
    // filename of script
    std::string script;
 
    // list of file names on which to operate
    std::vector <std::string> filenames;
 
    // vector of loaded archives
    std::vector < Reference::To<Archive> > archives;
    
    // name of file containing list of Archive filenames
    std::string metafile;
 
    // verbosity flags
    bool verbose;
    bool very_verbose;
 
    // sort filenames returned by dirglob
    bool sort_filenames;
  };
 
  class Application::Options : public Processor
  {
    public:
 
    virtual void add_options (CommandLine::Menu&) = 0;
 
    virtual void setup ();
 
    virtual void process (Archive*);
 
    virtual void finish (Archive*);
 
    virtual void finalize();
 
  protected:
 
    friend class Application;
 
    Reference::To<Application,false> application;
 
  };
 
  template<typename Compare>
  void Application::sort_archives (Compare compare)
  {
    archives.resize( filenames.size() );
    for (unsigned ifile=0; ifile < filenames.size(); ifile++)
      archives[ifile] = load (filenames[ifile]);
 
    std::sort (archives.begin(), archives.end(), compare);
  }
 
}
 
#endif