AbstractConsoleModule.java

/**
 * C-JDBC: Clustered JDBC.
 * Copyright (C) 2002-2004 French National Institute For Research In Computer
 * Science And Control (INRIA).
 * Contact: c-jdbc@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or any later
 * version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * Initial developer(s): Nicolas Modrzyk.
 * Contributor(s): Mathieu Peltier.
 */

package org.objectweb.cjdbc.console.text.module;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import java.util.TreeSet;

import jline.SimpleCompletor;

import org.objectweb.cjdbc.common.i18n.ConsoleTranslate;
import org.objectweb.cjdbc.console.text.Console;
import org.objectweb.cjdbc.console.text.commands.ConsoleCommand;
import org.objectweb.cjdbc.console.text.commands.Help;
import org.objectweb.cjdbc.console.text.commands.History;
import org.objectweb.cjdbc.console.text.commands.Quit;

/**
 * This class defines a AbstractConsoleModule
 * 
 * @author <a href="mailto:Nicolas.Modrzyk@inria.fr">Nicolas Modrzyk </a>
 * @author <a href="mailto:Mathieu.Peltier@inrialpes.fr">Mathieu Peltier </a>
 * @version 1.0
 */
public abstract class AbstractConsoleModule
{
  Console                  console;
  TreeSet                  commands;
  boolean                  quit;
  LinkedList               history;
  private static final int HISTORY_MAX = 10;

  /**
   * Creates a new <code>AbstractConsoleModule.java</code> object
   * 
   * @param console to refer from
   */
  public AbstractConsoleModule(Console console)
  {
    this.console = console;
    this.commands = new TreeSet();
    this.history = new LinkedList();
    commands.add(new Help(this));
    commands.add(new History(this));
    commands.add(new Quit(this));
    console.println(ConsoleTranslate.get("module.loading",
        getDescriptionString()));
    this.loadCommands();
    this.loadCompletor();
  }

  /**
   * Loads the commands for this module
   */
  protected abstract void loadCommands();

  protected void loadCompletor()
  {
    int size = commands.size();
    if (size <= 0)
      return;
    Iterator iter = commands.iterator();
    ArrayList list = new ArrayList(size);
    while (iter.hasNext())
    {
      list.add(((ConsoleCommand) iter.next()).getCommandName());
    }
    console.getConsoleReader().addCompletor(
        new SimpleCompletor((String[]) list.toArray(new String[size])));
  }

  /**
   * Text description of this module
   * 
   * @return <code>String</code> description to display
   */
  public abstract String getDescriptionString();

  /**
   * Display help for this module
   */
  public void help()
  {
    console.println(ConsoleTranslate.get("module.commands.available",
        getDescriptionString()));
    ConsoleCommand command;
    Iterator it = commands.iterator();
    while (it.hasNext())
    {
      command = (ConsoleCommand) it.next();
      console.printInfo(command.getCommandName() + " "
          + command.getCommandParameters());
      console.println("   " + command.getCommandDescription());
    }
  }

  /**
   * Quit this module
   */
  public void quit()
  {
    this.quit = true;
  }

  /**
   * Get all the commands for this module
   * 
   * @return <code>TreeSet</code> of commands (commandName|commandObject)
   */
  public TreeSet getCommands()
  {
    return commands;
  }

  /**
   * Get the prompt string for this module
   * 
   * @return <code>String</code> to place before prompt
   */
  public abstract String getPromptString();

  /**
   * Handle a serie of commands
   */
  public void handlePrompt()
  {
    if (quit)
    {
      console.printError(ConsoleTranslate.get("module.quitting",
          getDescriptionString()));
      return;
    }

    Hashtable hashCommands = getHashCommands();

    //login();
    quit = false;
    while (!quit)
    {
      try
      {
        String commandLine = console.readLine(getPromptString());
        if (commandLine == null)
        {
          quit = true;
          break;
        }
        if (commandLine.equals(""))
          continue;
        else
          manageHistory(commandLine);

        handleCommandLine(commandLine, hashCommands);

      }
      catch (Exception e)
      {
        console.printError(ConsoleTranslate.get("module.command.got.error",
            new Object[]{e.getClass(), e.getMessage()}), e);
      }
    }
  }

  /**
   * Get the list of commands as strings for this module
   * 
   * @return <code>Hashtable</code> list of <code>String</code> objects
   */
  public final Hashtable getHashCommands()
  {
    Hashtable hashCommands = new Hashtable();
    ConsoleCommand consoleCommand;
    Iterator it = commands.iterator();
    while (it.hasNext())
    {
      consoleCommand = (ConsoleCommand) it.next();
      hashCommands.put(consoleCommand.getCommandName(), consoleCommand);
    }
    return hashCommands;
  }

  /**
   * Handle module command
   * 
   * @param commandLine the command line to handle
   * @param hashCommands the list of commands available for this module
   * @throws Exception if fails
   */
  public final void handleCommandLine(String commandLine, Hashtable hashCommands)
      throws Exception
  {
    ConsoleCommand consoleCommand;
    StringTokenizer st = new StringTokenizer(commandLine);
    if (!st.hasMoreTokens())
    {
      console.printError(ConsoleTranslate.get("module.command.not.supported",
          ""));
      return;
    }
    String command = st.nextToken();
    consoleCommand = null; // reinit
    try
    {
      consoleCommand = (ConsoleCommand) hashCommands.get(command);
    }
    catch (NoSuchElementException e)
    {
      consoleCommand = null;
    }
    if (consoleCommand == null)
    {
      console.printError(ConsoleTranslate.get("module.command.not.supported",
          command));
    }
    else
    {
      consoleCommand.execute(commandLine.substring(command.length()));
    }
  }

  /**
   * Add the command to the history. Removes the first item in the list if the
   * history is too large.
   * 
   * @param command taken from the command line
   */
  public final void manageHistory(String command)
  {
    history.add(command);
    if (history.size() > HISTORY_MAX)
      history.removeFirst();
  }

  /**
   * Handles login in this module
   * 
   * @param params parameters to use to login in this module
   * @throws Exception if fails
   */
  public abstract void login(String[] params) throws Exception;

  /**
   * Get access to the console
   * 
   * @return <code>Console</code> instace
   */
  public Console getConsole()
  {
    return console;
  }

  /**
   * Returns the history value.
   * 
   * @return Returns the history.
   */
  public LinkedList getHistory()
  {
    return history;
  }
}

---