/* * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package com.sun.javafx.application; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import javafx.application.Application; import javafx.application.Application.Parameters; /** * Implementation class for Application parameters. This is called by the * applet or application launcher to create the startup parameters for the * given class. */ public class ParametersImpl extends Parameters { private List rawArgs = new ArrayList(); private Map namedParams = new HashMap(); private List unnamedParams = new ArrayList(); private List readonlyRawArgs = null; private Map readonlyNamedParams = null; private List readonlyUnnamedParams = null; // Set of parameters for each application private static Map params = new HashMap(); /** * Constructs an empty Parameters object. */ public ParametersImpl() { } /** * Constructs an Parameters object from the specified list of arguments. * The list may be null. * * @param args list of command line arguments */ public ParametersImpl(List args) { if (args != null) { init(args); } } /** * Constructs an Parameters object from the specified array of unnamed * parameters. The array may be null. * * @param args array of command line arguments */ public ParametersImpl(String[] args) { if (args != null) { init(Arrays.asList(args)); } } /** * Constructs an Parameters object from the specified map of named * parameters. * * @param params a map of parameters from which to initialize this * object. */ public ParametersImpl(Map params, String[] arguments) { init(params, arguments); } /** * Initialize this Parameters object from the set of command line arguments. * Null elements are elided. * * @param args list of command line arguments */ private void init(Listargs) { for (String arg: args) { if (arg != null) { rawArgs.add(arg); } } computeNamedParams(); computeUnnamedParams(); } /** * Constructs an Parameters object from the specified map of named * parameters. * * @param params a map of parameters from which to initialize this * object. */ private void init(Map params, String[] arguments) { for (Object e : params.entrySet()) { Object key = ((Map.Entry)e).getKey(); if (validKey(key)) { Object value = params.get(key); if (value instanceof String) { namedParams.put((String)key, (String)value); } } } computeRawArgs(); if (arguments != null) { for (String arg : arguments) { unnamedParams.add(arg); rawArgs.add(arg); } } } /** * Validate the first character of a key. It is valid if it is a letter or * an "_" character. * * @param c the first char of a key string * * @return whether or not it is valid */ private boolean validFirstChar(char c) { return Character.isLetter(c) || c == '_'; } /** * Validate the key. A key is valid if it is a String object that starts * with a letter or "_" character and does not contain an "=" character. * * @param key Object representing a potential key * * @return true if key is a valid key, otherwise false */ private boolean validKey(Object key) { if (key instanceof String) { String keyStr = (String)key; if (keyStr.length() > 0 && keyStr.indexOf('=') < 0) { return validFirstChar(keyStr.charAt(0)); } } return false; } /** * Returns true if the specified string is a named parameter of the * form: --name=value * * @param arg the string to check * * @return true if the string matches the pattern for a named parameter. */ private boolean isNamedParam(String arg) { if (arg.startsWith("--")) { return (arg.indexOf('=') > 2 && validFirstChar(arg.charAt(2))); } else { return false; } } /** * This method computes the list of unnamed parameters, by filtering the * list of raw arguments, stripping out the named parameters. */ private void computeUnnamedParams() { for (String arg : rawArgs) { if (!isNamedParam(arg)) { unnamedParams.add(arg); } } } /** * This method parses the current array of raw arguments looking for * name,value pairs. These name,value pairs are then added to the map * for this parameters object, and are of the form: --name=value. */ private void computeNamedParams() { for (String arg : rawArgs) { if (isNamedParam(arg)) { final int eqIdx = arg.indexOf('='); String key = arg.substring(2, eqIdx); String value = arg.substring(eqIdx + 1); namedParams.put(key, value); } } } /** * This method creates string representations of the name,value pairs in * the map for this Parameters object, and appends those strings to the * raw arguments array. The newly added strings are of the form: * "--name=value". */ private void computeRawArgs() { ArrayList keys = new ArrayList(); keys.addAll(namedParams.keySet()); Collections.sort(keys); for (String key : keys) { rawArgs.add("--" + key + "=" + namedParams.get(key)); } } @Override public List getRaw() { if (readonlyRawArgs == null) { readonlyRawArgs = Collections.unmodifiableList(rawArgs); } return readonlyRawArgs; } @Override public Map getNamed() { if (readonlyNamedParams == null) { readonlyNamedParams = Collections.unmodifiableMap(namedParams); } return readonlyNamedParams; } @Override public List getUnnamed() { if (readonlyUnnamedParams == null) { readonlyUnnamedParams = Collections.unmodifiableList(unnamedParams); } return readonlyUnnamedParams; } // Accessor methods public static Parameters getParameters(Application app) { Parameters p = params.get(app); return p; } public static void registerParameters(Application app, Parameters p) { params.put(app, p); } }