Interpreter.h

/***************************************************************************
 *
 *   Copyright (C) 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __Pulsar_Interpreter_h
#define __Pulsar_Interpreter_h
 
#include "CommandParser.h"
#include "TextInterface.h"
#include "Reference.h"
#include "tostring.h"
 
#include <map>
#include <stack>
 
namespace Pulsar {
  
  class Archive;
  class Weight;
  class ScatteredPowerCorrection;
  class ImageCorrection;
  
 
  class Interpreter : public CommandParser {
    
  public:
 
    enum Status { Good, Warn, Fail, TestFailed, CommandFailed, Undefined };
 
    Interpreter ();
 
    Interpreter (int &argc, char** &argv);
 
    ~Interpreter ();
 
    bool evaluate (const std::string& expression);
 
    void set (Archive* data);
 
    Archive* get ();
 
    bool has () const;
 
    void setmap (const std::string& name, Archive* data);
 
    Archive* getmap (const std::string& name, bool throw_exception = true);
 
    Status get_status () const { return status; }
 
    void set_reply (bool f) { reply = f; }
 
    std::string get_report (const std::string& args);
    
    std::string load (const std::string& args);
 
    std::string unload (const std::string& args);
 
    std::string push (const std::string& args);
 
    std::string pop (const std::string& args);
 
    std::string set (const std::string& args);
 
    std::string get (const std::string& args);
 
    std::string remove (const std::string& args);
 
    std::string clone (const std::string& args);
 
    std::string convert (const std::string& args);
 
    std::string extract (const std::string& args);
 
    std::string echo (const std::string& args);
 
    std::string edit (const std::string& args);
 
 
    std::string system (const std::string& args);
 
 
    std::string test (const std::string& args);
 
    std::string config (const std::string& args);
 
    std::string append (const std::string& args);
 
    std::string freq_append (const std::string& args);
 
    std::string shuffle (const std::string& args);
 
    std::string fscrunch (const std::string& args);
    
    std::string tscrunch (const std::string& args);
    
    std::string pscrunch (const std::string& args);
    
    std::string state (const std::string& args);
 
    std::string invint (const std::string& args);
 
    std::string bscrunch (const std::string& args);
    
    std::string fold (const std::string& args);
    
    std::string centre (const std::string& args);
    
    std::string dedisperse (const std::string& args);
 
    std::string defaraday (const std::string& args);
 
    std::string weight (const std::string& args);
 
    std::string scale (const std::string& args);
 
    std::string offset (const std::string& args);
 
    std::string rotate (const std::string& args);
 
    std::string dynspec (const std::string& args);
 
    std::string correct_instrument (const std::string& args);
    
    std::string scattered_power_correct (const std::string& args);
 
    std::string image_correct (const std::string& args);
 
    std::string screen_dump (const std::string& args);
 
    std::string toggle_clobber (const std::string& args);
 
    std::string toggle_evaluate (const std::string& args);
 
    class Extension;
 
    void import (Extension*);
 
    void import (Extension*, 
                 const std::string& command, 
                 const std::string& help);
 
    bool allow_infinite_frequency;
 
  protected:
    
    std::stack< Reference::To<Archive> > theStack;
 
    std::map< std::string, Reference::To<Archive> > theMap;
 
    TextInterface::Parser* get_interface ();
 
    bool inplace;
    
    bool clobber;
 
    // commands that request expansion will have arguments evaluated
    bool evaluation_enabled;
    
    bool stopwatch;
    
    bool reply;
   
    Status status;
 
    std::string unload_extension;
    
    std::string unload_path;
 
    std::vector<std::string> setup (const std::string& args, bool expand=true);
 
    std::string response (Status status, const std::string& text = "");
 
    Status get_status (const Error& error);
 
    std::string response (const Error& error);
 
    template<typename T> T setup (const std::string& args);
 
    template<typename T> T setup (const std::string& args, T default_value);
 
    Reference::To<Weight> weight_policy;
 
  private:
    
    void init ();
 
    std::string evaluate_expression;
 
    Reference::To<TextInterface::Parser> current_interface;
 
    Reference::To<ScatteredPowerCorrection> spc_algorithm;
 
    Reference::To<ImageCorrection> img_algorithm;
    
  };
  
}
 
template<typename T>
T Pulsar::Interpreter::setup (const std::string& args)
{
  std::vector<std::string> arguments = setup (args);
  if (arguments.size() != 1)
    throw Error (InvalidParam, "Pulsar::Interpreter::setup",
                 "invalid number of parameters");
  
  return fromstring<T> (arguments[0]);
}
 
template<typename T>
T Pulsar::Interpreter::setup (const std::string& args, T default_value)
{
  std::vector<std::string> arguments = setup (args);
  if (arguments.size() > 1)
    throw Error (InvalidParam, "Pulsar::Interpreter::setup",
                 "invalid number of parameters");
  if (arguments.size())
    return fromstring<T> (arguments[0]);
  else
    return default_value;
}
 
// standard shell constructor defined in More/Polarimetry/standard_shell.C
Pulsar::Interpreter* standard_shell ();
 
#endif