コード例 #1
0
/**
 * class used to store configuration options.
 *
 * <p>Created: Thu Sep 30 11:54:42 2010
 *
 * @author <a href="mailto:nuno [dot] lopes [at] deri [dot] org">Nuno Lopes</a>
 * @version 1.0
 */
public class Configuration {

  static Logger logger = Logger.getLogger(XSPARQLProcessor.class.getClass().getName());

  /** Parse in debug mode */
  private static boolean debug = false;

  /** Lexer in debug mode */
  private static boolean debuglexer = false;

  /** Show debug information */
  private static boolean verbose = false;

  /** use validating XQuery engine */
  private static boolean validatingXQuery = false;

  /** Print AST? */
  private static boolean ast = false;

  /** File array of the query files */
  private static File[] queryFiles;

  /** True if AST pictures should be generated */
  private static boolean dot = false;

  /** File the result query is written to */
  private static File outputFile = null;

  /** method to be used to perform SPARQL queries. By default requires a Joseki endpoint */
  private static String SPARQLmethod = "arq";

  /** XQuery engine to be used for evaluation/code production. */
  private static String xqueryEngine = "saxon";

  /** Evaluate the query */
  private static boolean evaluate = true;

  /** Create a debug version of the query */
  private static boolean debugVersion;

  /** SPARQL endpoint uri */
  private static String endpointURI;

  private static boolean warnIfNestedConstruct = false;

  /*
   * external variables for Xquery evaluation
   */
  private static Map<String, String> xqueryExternalVars = new HashMap<String, String>();

  private static String TDBLocation = System.getProperty("user.home") + "/.xsparql/TDB";

  // --------------------------------------------------- ACCESS Methods

  /** Parse in debug mode */
  public static boolean debug() {
    return debug;
  }

  /** Show debug information */
  public static boolean verbose() {
    return verbose;
  }

  /** Lexer in debug mode */
  public static boolean debuglexer() {
    return debuglexer;
  }

  /** use validating XQuery engine */
  public static boolean validatingXQuery() {
    return validatingXQuery;
  }

  /** Print AST? */
  public static boolean printAst() {
    return ast;
  }

  /** File array of the query files */
  public static File[] queryFiles() {
    return queryFiles;
  }

  /** True if AST pictures should be generated */
  public static boolean printDot() {
    return dot;
  }

  /** File the result query is written to */
  public static File outputFile() {
    return outputFile;
  }

  /** method to be used to perform SPARQL queries. By default requires a Joseki endpoint */
  public static String SPARQLmethod() {
    return SPARQLmethod;
  }

  /** XQuery engine to be used for evaluation/code production. */
  public static String xqueryEngine() {
    return xqueryEngine;
  }

  /** evaluate the query? */
  public static boolean evaluate() {
    return evaluate;
  }

  /** Create a debug version of the query */
  public static boolean debugVersion() {
    return debugVersion;
  }

  /** SPARQL endpoint uri */
  public static String endpointURI() {
    return endpointURI;
  }

  public static boolean warnIfNestedConstruct() {
    return warnIfNestedConstruct;
  }

  /*
   * external variables for Xquery evaluation
   */
  public static Map<String, String> xqueryExternalVars() {
    return xqueryExternalVars;
  };

  // --------------------------------------------------- command line parsing

  public static void setVerbose(boolean verbose) {

    if (verbose) {
      logger.setLevel(Level.ALL);

      logger.info(printParams());

    } else {
      logger.setLevel(Level.WARNING);
    }
  }

  public static void setValidating(boolean validating) {
    validatingXQuery = validating;
  }

  public static void setXQueryEngine(String engine) {
    xqueryEngine = engine;
  }

  /**
   * Parse program arguments
   *
   * @param args the same as for main(String[] args)
   */
  public static void parseOptions(final String[] args) {
    final OptionParser oparser = new OptionParser();
    oparser.accepts("p", "Parse in debug mode");
    oparser.accepts("l", "Put Lexer in debug mode");
    oparser.accepts("a", "Print AST between rewriting steps");
    oparser.accepts("d", "Create debug version");
    oparser.accepts("dot", "Save AST as PNG file (Graphviz needed)");
    final OptionSpec<File> fileFileOption =
        oparser.accepts("f", "Write result query to file").withRequiredArg().ofType(File.class);
    oparser
        .accepts("u", "SPARQL endpoint URI like \"http://localhost:2020/sparql?query=\"")
        .withRequiredArg();
    oparser.accepts("h", "Show Help");
    oparser.accepts("version", "Show version information");
    oparser.accepts("v", "Show debug information (verbose mode)");
    oparser.accepts("noval", "Use non-validating XQuery engine (default)");
    oparser.accepts("val", "Use validating XQuery engine");
    oparser.accepts("arq", "use ARQ API to perform SPARQL queries");
    oparser.accepts("joseki", "use Joseki endpoint to perform SPARQL queries");
    oparser.accepts("rewrite-only", "Only perform rewriting to XQuery");
    final OptionSpec<String> xqueryEval =
        oparser
            .accepts(
                "e",
                "Evaluate result query with the specified XQuery engine to use (saxon | qexo) ")
            .withRequiredArg()
            .ofType(String.class);

    final OptionSet options = oparser.parse(args);

    // parameters which lead to early exit
    if (options.has("h")) {
      System.out.println("USAGE: java -jar xsparql.jar [OPTIONS] [FILE]...");
      System.out.println();

      try {
        oparser.printHelpOn(System.out);
      } catch (IOException e) {
        e.printStackTrace();
      }
      System.exit(0);
    }

    // get version from jar file
    if (options.has("version")) {
      System.out.println(
          Main.class.getPackage().getImplementationTitle()
              + " version "
              + Main.class.getPackage().getImplementationVersion());
      System.exit(0);
    }

    if (options.has("noval") && options.has("val")) {
      System.err.println("Use either \"val\" or \"noval\". Using default.");
    } else if (options.has("noval")) {
      validatingXQuery = false;
    } else if (options.has("val")) {
      validatingXQuery = true;
    }

    // simple commandline switches
    verbose = options.has("v");
    dot = options.has("dot");
    debug = options.has("p");
    debuglexer = options.has("l");
    ast = options.has("a");

    if (options.has("arq") && options.has("joseki")) {
      System.err.println("Use either \"arq\" or \"joseki\". Using default.");
    } else if (options.has("arq")) {
      SPARQLmethod = "arq";
    } else if (options.has("joseki")) {
      SPARQLmethod = "joseki";
    }

    // XQuery engine specification
    if (options.has(xqueryEval)) {
      xqueryEngine = options.valueOf(xqueryEval);
    }

    if (options.has("rewrite-only")) {
      evaluate = false;
    }

    if (options.has("d")) {
      debugVersion = options.has("d");
      verbose = true;
    }

    // serverMode = options.has("s");

    // query output file
    if (options.has(fileFileOption)) {
      outputFile = options.valueOf(fileFileOption);
    }

    // SPARQL endpoint URI
    if (options.has("u")) {
      endpointURI = options.valueOf("u").toString();
    }

    // get all the names of the XSPARQL query files
    final List<File> queryFilesList = new ArrayList<File>();

    for (String filename : options.nonOptionArguments()) {
      if (filename.contains("=")) { // Xquery external variable
        xqueryExternalVars.put(
            filename.substring(0, filename.indexOf("=")),
            filename.substring(filename.indexOf("=") + 1));
      } else {
        queryFilesList.add(new File(filename)); // really a filename
      }
    }

    queryFiles = queryFilesList.toArray(new File[0]);

    if (options.has("u") && !xqueryEngine.equals("")) {
      // if you don't use a local sparql endpoint (otherwise you wouldn't
      // use the -u) and you want to evaluate the
      // query right after the translation then under the additional
      // condition that the query contains a nested
      // construct the evaluation wont work -> check for a nested
      // construct during translation
      warnIfNestedConstruct = true;
    }

    setVerbose(verbose);
  }

  public static xqueryEvaluator getEvaluator() {

    xqueryEvaluator eval = null;

    if (xqueryEngine.equals("saxon")) {
      eval = new xqueryEvaluatorSaxon();
    }

    // if (xqueryEngine.equals("qexo")) {
    //    eval = new xqueryEvaluatorQexo();
    // }

    return eval;
  }

  public static String getTDBLocation() {

    return TDBLocation;
  }

  /** {@inheritDoc} */
  public static String printParams() {
    final int sbSize = 1000;
    final String variableSeparator = "  ";
    final StringBuffer sb = new StringBuffer(sbSize);

    sb.append("logger=").append(logger);
    sb.append(variableSeparator);
    sb.append("debug=").append(debug);
    sb.append(variableSeparator);
    sb.append("debuglexer=").append(debuglexer);
    sb.append(variableSeparator);
    sb.append("verbose=").append(verbose);
    sb.append(variableSeparator);
    sb.append("validatingXQuery=").append(validatingXQuery);
    sb.append(variableSeparator);
    sb.append("ast=").append(ast);
    sb.append(variableSeparator);
    sb.append("queryFiles=").append(queryFiles);
    sb.append(variableSeparator);
    sb.append("dot=").append(dot);
    sb.append(variableSeparator);
    sb.append("outputFile=");
    if (outputFile != null) {
      sb.append(outputFile);
    }
    sb.append(variableSeparator);
    sb.append("SPARQLmethod=").append(SPARQLmethod);
    sb.append(variableSeparator);
    sb.append("xqueryEngine=").append(xqueryEngine);
    sb.append(variableSeparator);
    sb.append("evaluate=").append(evaluate);
    sb.append(variableSeparator);
    sb.append("debugVersion=").append(debugVersion);
    sb.append(variableSeparator);
    sb.append("endpointURI=").append(endpointURI);
    sb.append(variableSeparator);
    sb.append("warnIfNestedConstruct=").append(warnIfNestedConstruct);

    return sb.toString();
  }
}
コード例 #2
0
  /**
   * Parse program arguments
   *
   * @param args the same as for main(String[] args)
   */
  public static void parseOptions(final String[] args) {
    final OptionParser oparser = new OptionParser();
    oparser.accepts("p", "Parse in debug mode");
    oparser.accepts("l", "Put Lexer in debug mode");
    oparser.accepts("a", "Print AST between rewriting steps");
    oparser.accepts("d", "Create debug version");
    oparser.accepts("dot", "Save AST as PNG file (Graphviz needed)");
    final OptionSpec<File> fileFileOption =
        oparser.accepts("f", "Write result query to file").withRequiredArg().ofType(File.class);
    oparser
        .accepts("u", "SPARQL endpoint URI like \"http://localhost:2020/sparql?query=\"")
        .withRequiredArg();
    oparser.accepts("h", "Show Help");
    oparser.accepts("version", "Show version information");
    oparser.accepts("v", "Show debug information (verbose mode)");
    oparser.accepts("noval", "Use non-validating XQuery engine (default)");
    oparser.accepts("val", "Use validating XQuery engine");
    oparser.accepts("arq", "use ARQ API to perform SPARQL queries");
    oparser.accepts("joseki", "use Joseki endpoint to perform SPARQL queries");
    oparser.accepts("rewrite-only", "Only perform rewriting to XQuery");
    final OptionSpec<String> xqueryEval =
        oparser
            .accepts(
                "e",
                "Evaluate result query with the specified XQuery engine to use (saxon | qexo) ")
            .withRequiredArg()
            .ofType(String.class);

    final OptionSet options = oparser.parse(args);

    // parameters which lead to early exit
    if (options.has("h")) {
      System.out.println("USAGE: java -jar xsparql.jar [OPTIONS] [FILE]...");
      System.out.println();

      try {
        oparser.printHelpOn(System.out);
      } catch (IOException e) {
        e.printStackTrace();
      }
      System.exit(0);
    }

    // get version from jar file
    if (options.has("version")) {
      System.out.println(
          Main.class.getPackage().getImplementationTitle()
              + " version "
              + Main.class.getPackage().getImplementationVersion());
      System.exit(0);
    }

    if (options.has("noval") && options.has("val")) {
      System.err.println("Use either \"val\" or \"noval\". Using default.");
    } else if (options.has("noval")) {
      validatingXQuery = false;
    } else if (options.has("val")) {
      validatingXQuery = true;
    }

    // simple commandline switches
    verbose = options.has("v");
    dot = options.has("dot");
    debug = options.has("p");
    debuglexer = options.has("l");
    ast = options.has("a");

    if (options.has("arq") && options.has("joseki")) {
      System.err.println("Use either \"arq\" or \"joseki\". Using default.");
    } else if (options.has("arq")) {
      SPARQLmethod = "arq";
    } else if (options.has("joseki")) {
      SPARQLmethod = "joseki";
    }

    // XQuery engine specification
    if (options.has(xqueryEval)) {
      xqueryEngine = options.valueOf(xqueryEval);
    }

    if (options.has("rewrite-only")) {
      evaluate = false;
    }

    if (options.has("d")) {
      debugVersion = options.has("d");
      verbose = true;
    }

    // serverMode = options.has("s");

    // query output file
    if (options.has(fileFileOption)) {
      outputFile = options.valueOf(fileFileOption);
    }

    // SPARQL endpoint URI
    if (options.has("u")) {
      endpointURI = options.valueOf("u").toString();
    }

    // get all the names of the XSPARQL query files
    final List<File> queryFilesList = new ArrayList<File>();

    for (String filename : options.nonOptionArguments()) {
      if (filename.contains("=")) { // Xquery external variable
        xqueryExternalVars.put(
            filename.substring(0, filename.indexOf("=")),
            filename.substring(filename.indexOf("=") + 1));
      } else {
        queryFilesList.add(new File(filename)); // really a filename
      }
    }

    queryFiles = queryFilesList.toArray(new File[0]);

    if (options.has("u") && !xqueryEngine.equals("")) {
      // if you don't use a local sparql endpoint (otherwise you wouldn't
      // use the -u) and you want to evaluate the
      // query right after the translation then under the additional
      // condition that the query contains a nested
      // construct the evaluation wont work -> check for a nested
      // construct during translation
      warnIfNestedConstruct = true;
    }

    setVerbose(verbose);
  }