Crunch big numbers with GT3 using a quadratic sieve

package factorization.client;

/**
 * Title: Factorization Library
 * Description: A factorization lib based on the quadratic sieve
 * Copyright: Copyright (c) 2004
 * Company: ACME
 * @author Vladimir Silva
 * @version 1.0
 */

import factorization.service.Factorization.FactorizationServiceGridLocator;
import factorization.service.Factorization.FactorizationPortType;
import java.net.URL;

/**
 * Factorization Service client
 * Usage: FactorizationClient -factory [URL] -n [BIG_NUM] -out [OUTFILE_PATH]
 *					{-verboseServer}
 *  {-verboseServer} : optional
 */
public class FactorizationClient
{
      private static final String PROGRAM_NAME = "FactorizationClient";
      private static final String USAGE = PROGRAM_NAME +
	" -factory URL -n [NUMBER2FACTOR] -out [OUT_FILE_PATH] -verboseServer";

      // Factorization factory service URL.
      // Example: http://localhost:8080/ogsa/services/
      // 	factorization/FactorizationService/{INSTANCE-NAME}
      private URL _GSH = null;

      // Big Number to factor
      private String _number = null;

      // Server side output file
      private String _outFile = null;
      private String _options = "-noverbose";
      private String _message = null;

      /*
       * Constructor
       */
      public FactorizationClient(String[] args) throws Exception
      {
            if ( ! parseArgs(args) )
                  throw new Exception(_message);
            if ( ! validateArgs() )
                  throw new Exception(_message);

            // Get a reference to the MathService instance
            FactorizationServiceGridLocator loc = new FactorizationServiceGridLocator();
            FactorizationPortType fac = loc.getFactorizationService(_GSH);

            // call remote Method: factorize (num, out file, options)
            String ret = fac.factorize(_number, _outFile, _options);

            // display remote serv  out
            System.out.println("Factorization Service returned:" + ret);
      }

      /*
       * Parse input args
       */
      boolean parseArgs(String args[]) throws Exception {
            String arg;
            for (int i = 0; i < args.length; i++) {
                  arg = args[i].trim();
                  if ( arg.length() == 0 ) continue;

                  if (arg.equals("-factory"))
	      _GSH = new URL(args[++i]);
	 else if ( arg.equals("-n"))
	      _number = args[++i];
	 else if (arg.equals("-out"))
                        _outFile = args[++i];
                  else if ( arg.equals("-verboseServer") )
                        _options = "-verbose";
                  else {
                        _message = "Invalid argument(s): " + args[i];
                        return false;
                  }
            }
            return true;
      }

      /*
       * Validate program arguments
       */
      boolean validateArgs () {
            if ( _GSH == null || _number == null ) {
                  _message = "Service factory and number are required.\n" + USAGE;
                  return false;
            }
            if ( _number.length() == 0 ) {
                  _message = "A valid number is required.\n" + USAGE;
                  return false;
            }
            return true;
      }

      static void usage() {
            System.out.println(USAGE);
      }

      /*
       * Main Sub
       */
      public static void main(String[] args) {
            try {
                  FactorizationClient c = new FactorizationClient(args);
            }
            catch (Exception ex) {
                  ex.printStackTrace();
                  System.err.println(ex);
            }
      }
}