Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package uk.co.flamingpenguin.jewel.cli;
  
  import java.util.List;
  import java.util.Map;
  
  class ParsedArgumentsBuilder implements ArgumentParser
 {
   
The state of the parser

Author(s):
t.wood
 
    private enum ParsingState
    {
       Initial,
       OptionOrValue,
       NoOptions,
       Unparsed;
    }
 
    private final Map<StringList<String>> m_arguments = new LinkedHashMap<StringList<String>>();
    private final List<Stringm_unparsed = new ArrayList<String>();
 
    private List<Stringm_currentValues;

   
 
    public ArgumentCollection parseArguments(final String... argumentsthrows ArgumentValidationException
    {
       for (final String argument : arguments)
       {
          add(argument);
       }
       return getParsedArguments();
    }

   
Add an argument to the set

Parameters:
argument the argument to parse
Throws:
ArgumentValidationException
 
    void add(final String argumentthrows ArgumentValidationException
    {
       if(startsWithDash(argument) && !.equals(.))
       {
          if(startsWithDoubleDash(argument))
          {
             if(argument.length() > 2)
             {
                addOptionAndValue(argument);
             }
             else
             {
                changeToUnparsedState();
             }
          }
          else
          {
             addConjoinedOptions(argument.substring(1));
          }
       }
       else
       {
          addValue(argument);
       }
    }
 
    private void addConjoinedOptions(final String optionsthrows ArgumentValidationException
    {
       for (int i = 0; i < options.length(); i++)
       {
          addOption(options.substring(ii+1));
       }
    }
 
    private void addOptionAndValue(final String argumentthrows ArgumentValidationException
    {
       if(argument.contains("="))
       {
          final int separatorIndex = argument.indexOf("=");
          addOption(argument.substring(2, separatorIndex).trim());
 
          if(argument.length() > (separatorIndex + 1))
          {
             addValue(argument.substring(separatorIndex + 1).trim());
          }
       }
       else
       {
          addOption(argument.substring(2, argument.length()).trim());
       }
    }
   private void addValue(final String value)
   {
      switch ()
      {
         case :
             = .;
         case :
         case :
            .add(value);
            break;
         case :
            .add(value);
            break;
      }
   }
   private void addOption(final String optionthrows ArgumentValidationException
   {
      switch ()
      {
         case :
         case :
             = .;
             = new ArrayList<String>();
            .put(option);
            break;
         case :
         case :
               public ErrorType getErrorType()
               {
                  return ...;
               }
               public String getMessage()
               {
                  return option;
               }
               @Override
               public String toString()
               {
                  return String.format("Option not expected in this position: %s"getMessage());
               }});
      }
   }

   
Obtain the parsed arguments

Returns:
the arguments that have been parsed
   {
      final Map<StringList<String>> finalArguments = new LinkedHashMap<StringList<String>>();
      for (final Entry<StringList<String>> entry : .entrySet())
      {
         finalArguments.put(entry.getKey(), new ArrayList<String>(entry.getValue()));
      }
      return new ArgumentCollectionImpl(finalArgumentsnew ArrayList<String>());
   }
   private void changeToUnparsedState()
   {
       = null;
   }
   private boolean startsWithDash(final String argument)
   {
      return argument.length() > 1 && argument.startsWith("-");
   }
   private boolean startsWithDoubleDash(final String argument)
   {
      return argument.startsWith("--");
   }
New to GrepCode? Check out our FAQ X