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&) { }

    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;
 
    // set the commit hash compiled into application
    void set_commit_hash (const std::string& hash) { commit_hash = hash; }
 
    private:
 
    // commit hash compiled into application
    std::string commit_hash;
 
    // verify that commit hash compiled into application equals that compiled into library
    void verify_commit_hash ();
  };

  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