jena-base/src/main/java/jena/cmd/CmdLineArgs.java - jena - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package jena.cmd;

 import static java.nio.file.Files.readAllBytes;

 import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.ArrayList ;
 import java.util.Arrays ;
 import java.util.Collections ;
 import java.util.HashMap ;
 import java.util.Iterator ;
 import java.util.List ;
 import java.util.Map ;

 import org.apache.jena.atlas.logging.Log ;

 /**
  * Command line, using the common named/positional arguments paradigm
  * (also called options/arguments).
  */
 public class CmdLineArgs extends CommandLineBase {
     public CmdLineArgs(String[] args) {
         super(args) ;
     }

     private boolean processedArgs = false ;
     protected Map<String, ArgDecl> argMap = new HashMap<>() ;          // Map from string name to ArgDecl
     protected Map<String, Arg> args = new HashMap<>() ;            // Name to Arg
     protected List<String> positionals = new ArrayList<>() ;  // Positional arguments as strings.

     public void process() throws IllegalArgumentException
     {
         processedArgs = true ;
         apply(new ArgProcessor()) ;
     }

     // ---- Setting the ArgDecls

     /** Add an argument to those to be accepted on the command line.
      * @param argName Name
      * @param hasValue True if the command takes a (string) value
      * @return The CommandLine processor object
      */

     public CmdLineArgs add(String argName, boolean hasValue) {
         return add(new ArgDecl(hasValue, argName)) ;
     }

     /** Add an argument to those to be accepted on the command line.
      *  Argument order reflects ArgDecl.
      * @param hasValue True if the command takes a (string) value
      * @param argName Name
      * @return The CommandLine processor object
      */

     public CmdLineArgs add(boolean hasValue, String argName) {
         return add(new ArgDecl(hasValue, argName)) ;
     }

     /** Add an argument object
      * @param arg Argument to add
      * @return The CommandLine processor object
      */

     public CmdLineArgs add(ArgDecl arg) {
         for (Iterator<String> iter = arg.names(); iter.hasNext();) {
             String name = iter.next() ;
             if ( argMap.containsKey(name) )
                 Log.warn(this, "Argument '" + name + "' already added") ;
             argMap.put(name, arg) ;
         }
         return this ;
     }

     /**
      * Add a positional parameter
      * @param value
      * @return this object
      */
     public CmdLineArgs addPositional(String value) {
         positionals.add(value) ;
         return this ;
     }

     /**
      * Add a named argument which has no value.
      * @param name
      * @return this
      */
     public CmdLineArgs addArg(String name) {
         return addArg(name, null) ;
     }

     /**
      * Add a named argument/value pair
      * @param name
      * @param value
      * @return this object
      */
     public CmdLineArgs addArg(String name, String value) {
         if ( !args.containsKey(name) )
             args.put(name, new Arg(name)) ;
         Arg arg = args.get(name) ;
         return addArgWorker(arg, value) ;
     }

     private CmdLineArgs addArgWorker(Arg arg, String value) {
         ArgDecl argDecl = argMap.get(arg.getName()) ;

         if ( !argDecl.takesValue() && value != null )
             throw new IllegalArgumentException("No value for argument: " + arg.getName()) ;

         if ( argDecl.takesValue() ) {
             if ( value == null )
                 throw new IllegalArgumentException("No value for argument: " + arg.getName()) ;

             arg.setValue(value) ;
             arg.addValue(value) ;
         }

         return this ;
     }

     // ---- Indirection

     static final String DefaultIndirectMarker = "@" ;

     public boolean matchesIndirect(String s) { return matchesIndirect(s, DefaultIndirectMarker) ; }
     public boolean matchesIndirect(String s, String marker) { return s.startsWith(marker) ; }

     public String indirect(String s) { return indirect(s, DefaultIndirectMarker) ; }

     public String indirect(String s, String marker) {
         if ( !matchesIndirect(s, marker) )
             return s ;
         s = s.substring(marker.length()) ;
         try {
 			return new String(readAllBytes(Paths.get(s)));
 		} catch (IOException e) {
 			throw new CmdException("Could not read from: " + s, e);
 		}
     }

     // ---- Argument access

     /** Test whether an argument was seen. */

     public boolean contains(ArgDecl argDecl)    { return getArg(argDecl) != null ; }

     /** Test whether an argument was seen. */

     public boolean contains(String s)           { return getArg(s) != null ; }

     /** Test whether an argument was seen more than once */
     public boolean containsMultiple(String s)   { return getValues(s).size() > 1 ; }

     /** Test whether an argument was seen more than once */
     public boolean containsMultiple(ArgDecl argDecl) { return getValues(argDecl).size() > 1 ; }

     public boolean hasArgs() { return args.size() > 0 ; }

     /** Test whether the command line had a particular argument
      *
      * @param argName
      * @return this object
      */
     public boolean hasArg(String argName) { return getArg(argName) != null ; }

     /** Test whether the command line had a particular argument
      *
      * @param argDecl
      * @return true or false
      */

     public boolean hasArg(ArgDecl argDecl) { return getArg(argDecl) != null ; }


     /** Get the argument associated with the argument declaration.
      *  Actually returns the LAST one seen
      *  @param argDecl Argument declaration to find
      *  @return Last argument that matched.
      */

     public Arg getArg(ArgDecl argDecl) {
         Arg arg = null ;
         for ( Arg a : args.values() )
         {
             if ( argDecl.matches( a ) )
             {
                 arg = a;
             }
         }
         return arg ;
     }

     /** Get the argument associated with the argument name.
      *  Actually returns the LAST one seen
      *  @param argName Argument name
      *  @return Last argument that matched.
      */
     public Arg getArg(String argName) {
         argName = ArgDecl.canonicalForm(argName) ;
         return args.get(argName) ;
     }

     /**
      * Returns the value (a string) for an argument with a value -
      * returns null for no argument and no value.
      * @param argDecl
      * @return String
      */
     public String getValue(ArgDecl argDecl) {
         Arg arg = getArg(argDecl) ;
         if ( arg == null )
             return null ;
         if ( arg.hasValue() )
             return arg.getValue() ;
         return null ;
     }

     /**
      * Returns the value (a string) for an argument with a value -
      * returns null for no argument and no value.
      * @param argName
      * @return String
      */
     public String getValue(String argName) {
         Arg arg = getArg(argName) ;
         if ( arg == null )
             return null ;
         return arg.getValue() ;
     }

     /** Is the value something that looks like "true" or "yes"? */
     public boolean hasValueOfTrue(ArgDecl argDecl) {
         String x = getValue(argDecl) ;
         if ( x == null )
             return false ;
         if ( x.equalsIgnoreCase("true") || x.equalsIgnoreCase("t") ||
              x.equalsIgnoreCase("yes")  || x.equalsIgnoreCase("y") )
             return true ;
         return false ;
     }

     /** Is the value something that looks like "false" or "no"? */
     public boolean hasValueOfFalse(ArgDecl argDecl) {
         String x = getValue(argDecl) ;
         if ( x == null )
             return false ;
         if ( x.equalsIgnoreCase("false") || x.equalsIgnoreCase("f") ||
              x.equalsIgnoreCase("no") || x.equalsIgnoreCase("n") )
             return true ;
         return false ;
     }

     /**
      * Returns all the values (0 or more strings) for an argument.
      * @param argDecl
      * @return List
      */
     public List<String> getValues(ArgDecl argDecl) {
         Arg arg = getArg(argDecl) ;
         if ( arg == null )
             return new ArrayList<>() ;
         return arg.getValues() ;
     }

     /**
      * Returns all the values (0 or more strings) for an argument.
      * @param argName
      * @return List
      */
     public List<String> getValues(String argName) {
         Arg arg = getArg(argName) ;
         if ( arg == null )
             return new ArrayList<>() ;
         return arg.getValues() ;
     }

    // ---- Positional
     /** Get the i'th positional argument (indexed from 0)*/
     public String getPositionalArg(int i) {
         return positionals.get(i) ;
     }

     /** Return the number of positional arguments */
     public int getNumPositional() {
         return positionals.size() ;
     }

     public boolean hasPositional() {
         return positionals.size() > 0 ;
     }

     public List<String> getPositional() {
         return positionals ;
     }

     /** Return the positional arguments or "-" to indicate stdin */
     public List<String> getPositionalOrStdin() {
         if ( !positionals.isEmpty() )
             return Collections.unmodifiableList(positionals) ;
         List<String> x = Arrays.asList("-") ;
         return Collections.unmodifiableList(x) ;
     }

     // ----

     /**
      * Handle an unrecognised argument; default is to throw an exception
      * @param argStr The string image of the unrecognised argument
      */
     protected void handleUnrecognizedArg( String argStr ) {
         throw new CmdException("Unknown argument: "+argStr) ;
     }

     @Override
     public String toString() {
         if ( !processedArgs )
             return super.toString() ;
         String str = "" ;
         String sep = "" ;
         for ( String k : args.keySet() )
         {
             Arg a = args.get( k );
             str = str + sep + a;
             sep = " ";
         }
         sep = " -- " ;
         for ( String v : positionals )
         {
             str = str + sep + v;
             sep = " ";
         }
         return str ;
     }

     // ---- Process arguments after low level parsing and after ArgDecls added.
     class ArgProcessor implements ArgProc {
         boolean nextArgProcessed      = false ;
         boolean positionalArgsStarted = false ;

         @Override
         public void startArgs() {
             nextArgProcessed = false ;
             positionalArgsStarted = false ;
         }

         @Override
         public void finishArgs() {}

         @Override
         public void arg(String argStr, int i) {
             if ( nextArgProcessed ) {
                 nextArgProcessed = false ;
                 return ;
             }

             if ( positionalArgsStarted ) {
                 addPositional(argStr) ;
                 return ;
             }

             if ( argStr.equals("-") || argStr.equals("--") ) {
                 positionalArgsStarted = true ;
                 return ;
             }

             if ( !argStr.startsWith("-") ) {
                 // End of flags, start of positional arguments
                 positionalArgsStarted = true ;
                 addPositional(argStr) ;
                 return ;
             }

             argStr = ArgDecl.canonicalForm(argStr) ;
             if ( !argMap.containsKey(argStr) ) {
                 handleUnrecognizedArg(argStr) ;
                 return ;
             }

             // Recognized flag
             ArgDecl argDecl = argMap.get(argStr) ;

             if ( argDecl.takesValue() ) {
                 String val = getArg(i + 1) ;
                 // Use first name as the canonical one.
                 String x = argDecl.getKeyName() ;
                 addArg(x, val) ;
                 nextArgProcessed = true ;
             } else
                 addArg(argStr) ;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package jena.cmd;

	import static java.nio.file.Files.readAllBytes;

	import java.io.IOException;
	import java.nio.file.Paths;
	import java.util.ArrayList ;
	import java.util.Arrays ;
	import java.util.Collections ;
	import java.util.HashMap ;
	import java.util.Iterator ;
	import java.util.List ;
	import java.util.Map ;

	import org.apache.jena.atlas.logging.Log ;

	/**
	* Command line, using the common named/positional arguments paradigm
	* (also called options/arguments).
	*/
	public class CmdLineArgs extends CommandLineBase {
	public CmdLineArgs(String[] args) {
	super(args) ;
	}

	private boolean processedArgs = false ;
	protected Map<String, ArgDecl> argMap = new HashMap<>() ; // Map from string name to ArgDecl
	protected Map<String, Arg> args = new HashMap<>() ; // Name to Arg
	protected List<String> positionals = new ArrayList<>() ; // Positional arguments as strings.

	public void process() throws IllegalArgumentException
	{
	processedArgs = true ;
	apply(new ArgProcessor()) ;
	}

	// ---- Setting the ArgDecls

	/** Add an argument to those to be accepted on the command line.
	* @param argName Name
	* @param hasValue True if the command takes a (string) value
	* @return The CommandLine processor object
	*/

	public CmdLineArgs add(String argName, boolean hasValue) {
	return add(new ArgDecl(hasValue, argName)) ;
	}

	/** Add an argument to those to be accepted on the command line.
	* Argument order reflects ArgDecl.
	* @param hasValue True if the command takes a (string) value
	* @param argName Name
	* @return The CommandLine processor object
	*/

	public CmdLineArgs add(boolean hasValue, String argName) {
	return add(new ArgDecl(hasValue, argName)) ;
	}

	/** Add an argument object
	* @param arg Argument to add
	* @return The CommandLine processor object
	*/

	public CmdLineArgs add(ArgDecl arg) {
	for (Iterator<String> iter = arg.names(); iter.hasNext();) {
	String name = iter.next() ;
	if ( argMap.containsKey(name) )
	Log.warn(this, "Argument '" + name + "' already added") ;
	argMap.put(name, arg) ;
	}
	return this ;
	}

	/**
	* Add a positional parameter
	* @param value
	* @return this object
	*/
	public CmdLineArgs addPositional(String value) {
	positionals.add(value) ;
	return this ;
	}

	/**
	* Add a named argument which has no value.
	* @param name
	* @return this
	*/
	public CmdLineArgs addArg(String name) {
	return addArg(name, null) ;
	}

	/**
	* Add a named argument/value pair
	* @param name
	* @param value
	* @return this object
	*/
	public CmdLineArgs addArg(String name, String value) {
	if ( !args.containsKey(name) )
	args.put(name, new Arg(name)) ;
	Arg arg = args.get(name) ;
	return addArgWorker(arg, value) ;
	}

	private CmdLineArgs addArgWorker(Arg arg, String value) {
	ArgDecl argDecl = argMap.get(arg.getName()) ;

	if ( !argDecl.takesValue() && value != null )
	throw new IllegalArgumentException("No value for argument: " + arg.getName()) ;

	if ( argDecl.takesValue() ) {
	if ( value == null )
	throw new IllegalArgumentException("No value for argument: " + arg.getName()) ;

	arg.setValue(value) ;
	arg.addValue(value) ;
	}

	return this ;
	}

	// ---- Indirection

	static final String DefaultIndirectMarker = "@" ;

	public boolean matchesIndirect(String s) { return matchesIndirect(s, DefaultIndirectMarker) ; }
	public boolean matchesIndirect(String s, String marker) { return s.startsWith(marker) ; }

	public String indirect(String s) { return indirect(s, DefaultIndirectMarker) ; }

	public String indirect(String s, String marker) {
	if ( !matchesIndirect(s, marker) )
	return s ;
	s = s.substring(marker.length()) ;
	try {
	return new String(readAllBytes(Paths.get(s)));
	} catch (IOException e) {
	throw new CmdException("Could not read from: " + s, e);
	}
	}

	// ---- Argument access

	/** Test whether an argument was seen. */

	public boolean contains(ArgDecl argDecl) { return getArg(argDecl) != null ; }

	/** Test whether an argument was seen. */

	public boolean contains(String s) { return getArg(s) != null ; }

	/** Test whether an argument was seen more than once */
	public boolean containsMultiple(String s) { return getValues(s).size() > 1 ; }

	/** Test whether an argument was seen more than once */
	public boolean containsMultiple(ArgDecl argDecl) { return getValues(argDecl).size() > 1 ; }

	public boolean hasArgs() { return args.size() > 0 ; }

	/** Test whether the command line had a particular argument
	*
	* @param argName
	* @return this object
	*/
	public boolean hasArg(String argName) { return getArg(argName) != null ; }

	/** Test whether the command line had a particular argument
	*
	* @param argDecl
	* @return true or false
	*/

	public boolean hasArg(ArgDecl argDecl) { return getArg(argDecl) != null ; }


	/** Get the argument associated with the argument declaration.
	* Actually returns the LAST one seen
	* @param argDecl Argument declaration to find
	* @return Last argument that matched.
	*/

	public Arg getArg(ArgDecl argDecl) {
	Arg arg = null ;
	for ( Arg a : args.values() )
	{
	if ( argDecl.matches( a ) )
	{
	arg = a;
	}
	}
	return arg ;
	}

	/** Get the argument associated with the argument name.
	* Actually returns the LAST one seen
	* @param argName Argument name
	* @return Last argument that matched.
	*/
	public Arg getArg(String argName) {
	argName = ArgDecl.canonicalForm(argName) ;
	return args.get(argName) ;
	}

	/**
	* Returns the value (a string) for an argument with a value -
	* returns null for no argument and no value.
	* @param argDecl
	* @return String
	*/
	public String getValue(ArgDecl argDecl) {
	Arg arg = getArg(argDecl) ;
	if ( arg == null )
	return null ;
	if ( arg.hasValue() )
	return arg.getValue() ;
	return null ;
	}

	/**
	* Returns the value (a string) for an argument with a value -
	* returns null for no argument and no value.
	* @param argName
	* @return String
	*/
	public String getValue(String argName) {
	Arg arg = getArg(argName) ;
	if ( arg == null )
	return null ;
	return arg.getValue() ;
	}

	/** Is the value something that looks like "true" or "yes"? */
	public boolean hasValueOfTrue(ArgDecl argDecl) {
	String x = getValue(argDecl) ;
	if ( x == null )
	return false ;
	if ( x.equalsIgnoreCase("true") \|\| x.equalsIgnoreCase("t") \|\|
	x.equalsIgnoreCase("yes") \|\| x.equalsIgnoreCase("y") )
	return true ;
	return false ;
	}

	/** Is the value something that looks like "false" or "no"? */
	public boolean hasValueOfFalse(ArgDecl argDecl) {
	String x = getValue(argDecl) ;
	if ( x == null )
	return false ;
	if ( x.equalsIgnoreCase("false") \|\| x.equalsIgnoreCase("f") \|\|
	x.equalsIgnoreCase("no") \|\| x.equalsIgnoreCase("n") )
	return true ;
	return false ;
	}

	/**
	* Returns all the values (0 or more strings) for an argument.
	* @param argDecl
	* @return List
	*/
	public List<String> getValues(ArgDecl argDecl) {
	Arg arg = getArg(argDecl) ;
	if ( arg == null )
	return new ArrayList<>() ;
	return arg.getValues() ;
	}

	/**
	* Returns all the values (0 or more strings) for an argument.
	* @param argName
	* @return List
	*/
	public List<String> getValues(String argName) {
	Arg arg = getArg(argName) ;
	if ( arg == null )
	return new ArrayList<>() ;
	return arg.getValues() ;
	}

	// ---- Positional
	/** Get the i'th positional argument (indexed from 0)*/
	public String getPositionalArg(int i) {
	return positionals.get(i) ;
	}

	/** Return the number of positional arguments */
	public int getNumPositional() {
	return positionals.size() ;
	}

	public boolean hasPositional() {
	return positionals.size() > 0 ;
	}

	public List<String> getPositional() {
	return positionals ;
	}

	/** Return the positional arguments or "-" to indicate stdin */
	public List<String> getPositionalOrStdin() {
	if ( !positionals.isEmpty() )
	return Collections.unmodifiableList(positionals) ;
	List<String> x = Arrays.asList("-") ;
	return Collections.unmodifiableList(x) ;
	}

	// ----

	/**
	* Handle an unrecognised argument; default is to throw an exception
	* @param argStr The string image of the unrecognised argument
	*/
	protected void handleUnrecognizedArg( String argStr ) {
	throw new CmdException("Unknown argument: "+argStr) ;
	}

	@Override
	public String toString() {
	if ( !processedArgs )
	return super.toString() ;
	String str = "" ;
	String sep = "" ;
	for ( String k : args.keySet() )
	{
	Arg a = args.get( k );
	str = str + sep + a;
	sep = " ";
	}
	sep = " -- " ;
	for ( String v : positionals )
	{
	str = str + sep + v;
	sep = " ";
	}
	return str ;
	}

	// ---- Process arguments after low level parsing and after ArgDecls added.
	class ArgProcessor implements ArgProc {
	boolean nextArgProcessed = false ;
	boolean positionalArgsStarted = false ;

	@Override
	public void startArgs() {
	nextArgProcessed = false ;
	positionalArgsStarted = false ;
	}

	@Override
	public void finishArgs() {}

	@Override
	public void arg(String argStr, int i) {
	if ( nextArgProcessed ) {
	nextArgProcessed = false ;
	return ;
	}

	if ( positionalArgsStarted ) {
	addPositional(argStr) ;
	return ;
	}

	if ( argStr.equals("-") \|\| argStr.equals("--") ) {
	positionalArgsStarted = true ;
	return ;
	}

	if ( !argStr.startsWith("-") ) {
	// End of flags, start of positional arguments
	positionalArgsStarted = true ;
	addPositional(argStr) ;
	return ;
	}

	argStr = ArgDecl.canonicalForm(argStr) ;
	if ( !argMap.containsKey(argStr) ) {
	handleUnrecognizedArg(argStr) ;
	return ;
	}

	// Recognized flag
	ArgDecl argDecl = argMap.get(argStr) ;

	if ( argDecl.takesValue() ) {
	String val = getArg(i + 1) ;
	// Use first name as the canonical one.
	String x = argDecl.getKeyName() ;
	addArg(x, val) ;
	nextArgProcessed = true ;
	} else
	addArg(argStr) ;
	}
	}
	}