TextEditor.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2011 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/units/TextEditor.h
 
#ifndef __TextEditor_h
#define __TextEditor_h
 
#include "TextInterface.h"
#include "strutil.h"
 
template<class T>
class TextEditor : public Reference::Able
{
 
 public:
 
  TextEditor ()
    {
      prefix_name = true;
      output_identifier = true;
    }
 
  void add_commands (const std::string& str)
  { standard_separation (commands, str); }
 
  void add_script (const std::string& filename)
  { loadlines (filename, commands); }
 
  void add_extensions (const std::string& str)
  { standard_separation (extensions_to_add, str); }
 
  void remove_extensions (const std::string& str)
  { standard_separation (extensions_to_remove, str); }
 
  bool will_modify () const;
 
  std::string process (T*);
 
  virtual void add_extension (T*, const std::string& name) { }
 
  virtual void remove_extension (T*, const std::string& name) { }
 
  virtual std::string get_identifier (const T*) { return std::string(); }
 
  bool prefix_name;
 
  bool output_identifier;
 
  std::string delimiter;
 
  protected:
 
  std::vector<std::string> commands;
 
  std::vector<std::string> extensions_to_add;
 
  std::vector<std::string> extensions_to_remove;
 
};
 
template <typename T> 
bool TextEditor<T>::will_modify () const
{
  if (extensions_to_add.size() > 0 &&
      extensions_to_add[0] != "help")
    return true;
 
  if (extensions_to_remove.size() > 0)
    return true;
 
  for (unsigned j = 0; j < commands.size(); j++)
    if (commands[j].find('=') != std::string::npos &&
        commands[j].find("help") == std::string::npos)
      return true;
 
  return false;
}
 
template <typename T> 
std::string TextEditor<T>::process (T* instance)
{
  for (unsigned i = 0; i < extensions_to_add.size(); i++)
    add_extension (instance, extensions_to_add[i]);
 
  for (unsigned i = 0; i < extensions_to_remove.size(); i++)
    remove_extension (instance, extensions_to_remove[i]);
 
  std::string result;
 
  if (will_modify() && commands.size() == 0)
    return result;
 
  Reference::To<TextInterface::Parser> interface = instance->get_interface();
 
  if (commands.size() == 0)
    return interface->help (true);
 
  // so that a space precedes each parameter processed
  interface->set_indentation (" ");
  interface->set_prefix_name (prefix_name);
 
  if (delimiter.length())
    interface->set_delimiter (delimiter);
 
  if (output_identifier)
    result = get_identifier (instance);
 
  for (unsigned j = 0; j < commands.size(); j++)
    result += interface->process (commands[j]);
 
  return result;
}
 
#endif