Package jargs.gnu

Examples of jargs.gnu.CmdLineParser

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
                        "                  [{-w,--window} a_integer] [{-s,--step} a_integer]");
    }

    public static void main(String args[]) {

        CmdLineParser parser = new CmdLineParser();
        CmdLineParser.Option inFile = parser.addStringOption('f', "file");
        CmdLineParser.Option outFile = parser.addStringOption('o', "output");
        CmdLineParser.Option window = parser.addIntegerOption('w', "window");
        CmdLineParser.Option step = parser.addIntegerOption('s', "step");
        try {
            parser.parse(args);
        }
        catch (CmdLineParser.OptionException e) {
            System.err.println(e.getMessage());
            printUsage();
            System.exit(2);
        }

        windowSize =
                (Integer) parser.getOptionValue(window, 5);
        windowStep =
                (Integer) parser.getOptionValue(step, 1);

        SequenceGC sequence = new SequenceGC();
        String inPath = (String) parser.getOptionValue(inFile);
        String outPath = (String) parser.getOptionValue(outFile);

        if (!(inPath == null))
            sequence.ProcessPath(inPath, outPath);
        else
            printUsage();
View Full Code Here
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
        System.out.println("\nJSBuilder2 is a JavaScript and CSS project build tool.");
        System.out.println("For additional information, see http://extjs.com/products/jsbuilder/");
    }
   
    private static boolean parseArgs(String[] args) {
        CmdLineParser parser = new CmdLineParser();

        CmdLineParser.Option projectFileOpt = parser.addStringOption('p', "projectFile");
        CmdLineParser.Option homeDirOpt = parser.addStringOption('d', "homeDir");
        CmdLineParser.Option verboseOpt = parser.addBooleanOption('v', "verbose");
        CmdLineParser.Option helpOpt = parser.addBooleanOption('h', "help");       
        CmdLineParser.Option debugSuffixOpt = parser.addStringOption('s', "debugSuffix");
              
        CmdLineParser.Option sourceDirOpt = parser.addStringOption('f', "sourceDir");
        CmdLineParser.Option deployDirOpt = parser.addStringOption('n', "deployDir");
        CmdLineParser.Option forceEncodingOpt = parser.addStringOption('e', "forceEncoding");
        CmdLineParser.Option forceLineEndOpt = parser.addStringOption('l', "forceLineEnd");
        CmdLineParser.Option stripCommentsOpt = parser.addBooleanOption('c', "stripComments");
        CmdLineParser.Option removeTempPkgOpt = parser.addBooleanOption('t', "removeTempPkg");
        CmdLineParser.Option removeFilterOpt = parser.addStringOption('F', "removeFilter");
        CmdLineParser.Option deployModeOpt = parser.addBooleanOption('D', "deployMode");
              
        CmdLineParser.Option yuiLineBreakOpt = parser.addIntegerOption('L', "yui-line-break");
        CmdLineParser.Option yuiVerboseOpt = parser.addBooleanOption('V', "yui-verbose");
        CmdLineParser.Option yuiNoMungeOpt = parser.addBooleanOption('M', "yui-nomunge");
        CmdLineParser.Option yuiPreserveSimiOpt = parser.addBooleanOption('P', "yui-preserve-semi");
        CmdLineParser.Option yuiDisableOptOpt = parser.addBooleanOption('O', "yui-disable-optimizations");
        CmdLineParser.Option yuiCompressCssOpt = parser.addBooleanOption('C', "yui-compress-css");
        CmdLineParser.Option yuiCollapseLicOpt = parser.addBooleanOption('I', "yui-collapse-license");

        try {
            parser.parse(args);
        }
        catch ( CmdLineParser.OptionException e ) {
            System.err.println(e.getMessage());
            System.exit(2);
        }

        homeDir = (String)parser.getOptionValue(homeDirOpt, "");
        projectFile = (String)parser.getOptionValue(projectFileOpt, "");
        debugSuffix = (String)parser.getOptionValue(debugSuffixOpt, "-debug");
        verbose = (Boolean)parser.getOptionValue(verboseOpt, false);
        Boolean help = (Boolean)parser.getOptionValue(helpOpt, false);

        // process deploy mode first
        deployMode = (Boolean)parser.getOptionValue(deployModeOpt, false);
       
        sourceDir = (String)parser.getOptionValue(sourceDirOpt, null);
        deployDirName = (String)parser.getOptionValue(deployDirOpt, null);
        forceEncoding = (String)parser.getOptionValue(forceEncodingOpt, (deployMode) ? "UTF-8" : null);
        forceLineEnd = (String)parser.getOptionValue(forceLineEndOpt, (deployMode) ? "unix" : null);
        stripComments = (Boolean)parser.getOptionValue(stripCommentsOpt, (deployMode) ? true : false);
        removeTempPkg = (Boolean)parser.getOptionValue(removeTempPkgOpt, (deployMode) ? true : false);
        removeFilter = (String)parser.getOptionValue(removeFilterOpt, (deployMode) ? "pkgs;src;test;welcome;docs;ext.jsb2;index.html" : null);
               
        yuiLineBreak = (Integer)parser.getOptionValue(yuiLineBreakOpt, (deployMode) ? 1000 : -1);
        yuiVerbose = (Boolean)parser.getOptionValue(yuiVerboseOpt, false);
        yuiNoMunge = (Boolean)parser.getOptionValue(yuiNoMungeOpt, false);
        yuiPreserveSimi = (Boolean)parser.getOptionValue(yuiPreserveSimiOpt, false);
        yuiDisableOpt = (Boolean)parser.getOptionValue(yuiDisableOptOpt, false);
        yuiCompressCss = (Boolean)parser.getOptionValue(yuiCompressCssOpt, (deployMode) ? true : false);
        yuiCollapseLic = (Boolean)parser.getOptionValue(yuiCollapseLicOpt, (deployMode) ? true : false);

        // if help don't proceed
        if (help) {
            return false;
        }
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
    * @param args
    * @throws PackageManagerException
    */
   public static void main(String[] args) throws PackageManagerException
   {
      CmdLineParser cmdLineParser = new CmdLineParser();
      CmdLineParser.Option schemaFileCmdOption = cmdLineParser.addStringOption('f', "file");
      CmdLineParser.Option packageManagerHomeCmdOption = cmdLineParser.addStringOption('p', "pmhome");
     
      try
      {
         cmdLineParser.parse(args);
      }
      catch (CmdLineParser.OptionException e)
      {
         System.err.println("Error parsing command " + e.getMessage());
         printUsage();
         throw new PackageManagerException(e.getMessage());
      }
      // get package manager home
      String packageManagerHome = (String) cmdLineParser.getOptionValue(packageManagerHomeCmdOption);
      if (packageManagerHome == null)
      {
         throw new PackageManagerException("Package manager home has not been set");
      }
    
      File pmHome = new File(packageManagerHome);
      if (!pmHome.exists())
      {
         throw new PackageManagerException("Package manager home " + pmHome + " does not exist!");
      }
      logger.info("Using Package Manager Home: " + packageManagerHome);
      PackageManagerEnvironment env = new PackageManagerEnvironment(packageManagerHome);
     
      // Run the setup script
      String schemaSetupScript = (String) cmdLineParser.getOptionValue(schemaFileCmdOption);
      if (schemaSetupScript != null)
      {
         File schemaFile = new File(schemaSetupScript);
         if (!schemaFile.exists())
         {
View Full Code Here
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
    * @param args
    * @throws PackageManagerException
    */
   public static void main(String[] args) throws PackageManagerException
   {
      CmdLineParser cmdLineParser = new CmdLineParser();
      CmdLineParser.Option installCmdOption = cmdLineParser.addStringOption('i', "install");
      CmdLineParser.Option upgradeCmdOption = cmdLineParser.addStringOption('u', "upgrade");
      CmdLineParser.Option removeCmdOption = cmdLineParser.addStringOption('r', "remove");
      CmdLineParser.Option queryCmdOption = cmdLineParser.addBooleanOption('q', "query");
      CmdLineParser.Option packageManagerHomeCmdOption = cmdLineParser.addStringOption('p', "pmhome");
      CmdLineParser.Option jbossHomeCmdOption = cmdLineParser.addStringOption('s', "jbossHome");

      try
      {
         cmdLineParser.parse(args);
      }
      catch (CmdLineParser.OptionException e)
      {
         System.err.println("Error parsing command " + e.getMessage());
         printUsage();
         throw new PackageManagerException(e.getMessage());
      }
      File currentDir = new File(".");
      // Get the package manager home from system property. If not set, then defaults to
      // current directory
      String packageManagerHomeEnvVariableValue = System.getProperty(Constants.PACKAGE_MANAGER_HOME_SYSTEM_PROPERTY, currentDir.getAbsolutePath());
      // Override the package manager home if it's explicitly passed through the -p option
      String packageManagerHome = (String) cmdLineParser.getOptionValue(packageManagerHomeCmdOption,packageManagerHomeEnvVariableValue);
      if (packageManagerHome == null)
      {
         throw new PackageManagerException("Package manager home has not been set");
      }
    
      File pmHome = new File(packageManagerHome);
      if (!pmHome.exists())
      {
         throw new PackageManagerException("Package manager home " + pmHome + " does not exist!");
      }
      logger.info("Using Package Manager Home: " + packageManagerHome);
      PackageManagerEnvironment env = new PackageManagerEnvironment(packageManagerHome);
      // Check for JBOSS_HOME
      String jbossHome = (String) cmdLineParser.getOptionValue(jbossHomeCmdOption);
      if (packageManagerHome == null)
      {
         throw new PackageManagerException("Package manager home has not been set");
      }
      if (jbossHome == null)
      {
         throw new PackageManagerException("JBoss Home has not been set");
      }
      File jbHome = new File(jbossHome);
      if (!jbHome.exists())
      {
         throw new PackageManagerException("JBoss home " + jbHome + " does not exist!");
      }
      logger.info("Using JBoss Home: " + jbossHome);
     
      // Create a package manager now
      PackageManager pm = PackageManagerFactory.getDefaultPackageManager(env, jbossHome);

      // Parse the options from the command line and do appropriate action(s)
      Boolean query = (Boolean) cmdLineParser.getOptionValue(queryCmdOption, Boolean.FALSE);
      String packageToInstall = (String) cmdLineParser.getOptionValue(installCmdOption);
      String packageToUpgrade = (String) cmdLineParser.getOptionValue(upgradeCmdOption);
      String packageToRemove = (String) cmdLineParser.getOptionValue(removeCmdOption);
     
      if (query)
      {
         Set<String> installedPackages = pm.getAllInstalledPackages();
         if (installedPackages.isEmpty())
View Full Code Here
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
public class YUICompressor {

    public static void main(String args[]) {

        CmdLineParser parser = new CmdLineParser();
        CmdLineParser.Option typeOpt = parser.addStringOption("type");
        CmdLineParser.Option versionOpt = parser.addBooleanOption('V', "version");
        CmdLineParser.Option verboseOpt = parser.addBooleanOption('v', "verbose");
        CmdLineParser.Option nomungeOpt = parser.addBooleanOption("nomunge");
        CmdLineParser.Option linebreakOpt = parser.addStringOption("line-break");
        CmdLineParser.Option preserveSemiOpt = parser.addBooleanOption("preserve-semi");
        CmdLineParser.Option disableOptimizationsOpt = parser.addBooleanOption("disable-optimizations");
        CmdLineParser.Option helpOpt = parser.addBooleanOption('h', "help");
        CmdLineParser.Option charsetOpt = parser.addStringOption("charset");
        CmdLineParser.Option outputFilenameOpt = parser.addStringOption('o', "output");
        CmdLineParser.Option mungemapFilenameOpt = parser.addStringOption('m', "mungemap");

        Reader in = null;
        Writer out = null;
        Writer mungemap = null;

        try {

            parser.parse(args);

            Boolean help = (Boolean) parser.getOptionValue(helpOpt);
            if (help != null && help.booleanValue()) {
                usage();
                System.exit(0);
            }

            Boolean version = (Boolean) parser.getOptionValue(versionOpt);
            if (version != null && version.booleanValue()) {
                version();
                System.exit(0);
            }

            boolean verbose = parser.getOptionValue(verboseOpt) != null;

            String charset = (String) parser.getOptionValue(charsetOpt);
            if (charset == null || !Charset.isSupported(charset)) {
                // charset = System.getProperty("file.encoding");
                // if (charset == null) {
                //     charset = "UTF-8";
                // }

                // UTF-8 seems to be a better choice than what the system is reporting
                charset = "UTF-8";


                if (verbose) {
                    System.err.println("\n[INFO] Using charset " + charset);
                }
            }

            int linebreakpos = -1;
            String linebreakstr = (String) parser.getOptionValue(linebreakOpt);
            if (linebreakstr != null) {
                try {
                    linebreakpos = Integer.parseInt(linebreakstr, 10);
                } catch (NumberFormatException e) {
                    usage();
                    System.exit(1);
                }
            }

            String typeOverride = (String) parser.getOptionValue(typeOpt);
            if (typeOverride != null && !typeOverride.equalsIgnoreCase("js") && !typeOverride.equalsIgnoreCase("css")) {
                usage();
                System.exit(1);
            }

            boolean munge = parser.getOptionValue(nomungeOpt) == null;
            boolean preserveAllSemiColons = parser.getOptionValue(preserveSemiOpt) != null;
            boolean disableOptimizations = parser.getOptionValue(disableOptimizationsOpt) != null;

            String[] fileArgs = parser.getRemainingArgs();
            java.util.List files = java.util.Arrays.asList(fileArgs);
            if (files.isEmpty()) {
                if (typeOverride == null) {
                    usage();
                    System.exit(1);
                }
                files = new java.util.ArrayList();
                files.add("-"); // read from stdin
            }

            String output = (String) parser.getOptionValue(outputFilenameOpt);
            String pattern[];
            if(output == null) {
                pattern = new String[0];
            } else if (output.matches("(?i)^[a-z]\\:\\\\.*")){ // if output is with something like c:\ dont split it
                pattern = new String[]{output};
            } else {
                pattern = output.split(":");
            }
           
            try {
                String mungemapFilename = (String) parser.getOptionValue(mungemapFilenameOpt);
                if (mungemapFilename != null) {
                    mungemap = new OutputStreamWriter(new FileOutputStream(mungemapFilename), charset);
                }
            } catch (IOException e) {
                e.printStackTrace();
View Full Code Here
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
        }
    }
 
  public static void main(String[] args) {
    DeskshareMain dsMain = new DeskshareMain();
      CmdLineParser parser = new CmdLineParser();
     
      CmdLineParser.Option host = dsMain.addHelp(parser.addStringOption('s', "server"), serverHelpText);
        CmdLineParser.Option port = dsMain.addHelp(parser.addIntegerOption('p', "port"),"The port the application is listening");
        CmdLineParser.Option listenPort = dsMain.addHelp(parser.addIntegerOption('l', "listenPort"),"Port to listen for lifeline");
        CmdLineParser.Option room = dsMain.addHelp(parser.addStringOption('r', "room"),"Room");       
      CmdLineParser.Option cWidth = dsMain.addHelp(parser.addIntegerOption('w', "captureWidth"),"Width of the screen capture");
      CmdLineParser.Option cHeight = dsMain.addHelp(parser.addIntegerOption('t', "captureHeight"),"Height of the screen capture");
      CmdLineParser.Option sWidth = dsMain.addHelp(parser.addIntegerOption('d', "scaleWidth"),"Scale capture width");
      CmdLineParser.Option sHeight = dsMain.addHelp(parser.addIntegerOption('g', "scaleHeight"),"Scale capture height");   
//      CmdLineParser.Option quality = dsMain.addHelp(parser.addBooleanOption('q', "quality"),"Scale with better quality instead of speed");
//      CmdLineParser.Option aspectRatio = dsMain.addHelp(parser.addBooleanOption('a', "aspectRatio"),"Maintain aspect ratio when scaling");
//      CmdLineParser.Option autoScale = dsMain.addHelp(parser.addDoubleOption('a', "autoScale"),"Scale factor [0.5 to 0.8]. Override -d and -g options.");
      CmdLineParser.Option xCoord = dsMain.addHelp(parser.addIntegerOption('x', "x"),"Upper-left x coordinate of the screen capture");
      CmdLineParser.Option yCoord = dsMain.addHelp(parser.addIntegerOption('y', "y"),"Upper-left y coordinate of the screen capture");
      CmdLineParser.Option tryHttpTunnel = dsMain.addHelp(parser.addBooleanOption('n', "httptunnel"),"Http tunnel if direct connection fails");
      CmdLineParser.Option icon = dsMain.addHelp(parser.addStringOption('i', "icon"),"Path to system tray icon file");
      CmdLineParser.Option help = dsMain.addHelp(parser.addBooleanOption('h', "help"),"Show this help message");
      CmdLineParser.Option fullScreen = dsMain.addHelp(parser.addBooleanOption('f', "full-screen"),"Capture the full screen.");
      CmdLineParser.Option useSVC2 = dsMain.addHelp(parser.addBooleanOption('2', "useSVC2"),"Use Screen Video V2.");
       
        try {
            parser.parse(args);
        } catch (CmdLineParser.OptionException e) {
            System.err.println(e.getMessage());
            dsMain.printUsage();
            System.exit(2);
        }

        if (Boolean.TRUE.equals(parser.getOptionValue(help))) {
          dsMain.printUsage();
            System.exit(0);
        }
       
        // Extract the values entered for the various options -- if the
        // options were not specified, the corresponding values will be
        // the default.
        String hostValue = (String)parser.getOptionValue(host, "localhost");
        Integer portValue = (Integer)parser.getOptionValue(port, new Integer(9123));
        Integer listenPortValue = (Integer)parser.getOptionValue(listenPort, new Integer(9125));
        String roomValue = (String)parser.getOptionValue(room, "85115");
        Integer cWidthValue = (Integer)parser.getOptionValue(cWidth, new Integer(800));
        Integer cHeightValue = (Integer)parser.getOptionValue(cHeight, new Integer(600));
     
        Integer sWidthValue = (Integer)parser.getOptionValue(sWidth, new Integer(800));
        Integer sHeightValue = (Integer)parser.getOptionValue(sHeight, new Integer(600));
         
//        Boolean qualityValue = (Boolean)parser.getOptionValue(quality, new Boolean(false));
//        Double autoScaleValue = (Double)parser.getOptionValue(autoScale, new Double(0));
//        Double autoScaleValue = new Double(0);
//        Boolean aspectValue = (Boolean)parser.getOptionValue(aspectRatio, new Boolean(false));
        Integer xValue = (Integer)parser.getOptionValue(xCoord, new Integer(0));
        Integer yValue = (Integer)parser.getOptionValue(yCoord, new Integer(0));
        Boolean tunnelValue = (Boolean)parser.getOptionValue(tryHttpTunnel, new Boolean(false));
        String iconValue = (String)parser.getOptionValue(icon, "bbb.gif");
        Boolean fullScreenValue = (Boolean)parser.getOptionValue(fullScreen, new Boolean(false));
        Boolean useSVC2Value = (Boolean)parser.getOptionValue(useSVC2, new Boolean(false));
       
        Image image = Toolkit.getDefaultToolkit().getImage(iconValue);
       
        lifeline = new LifeLine(listenPortValue.intValue(), dsMain);
        lifeline.listen();
View Full Code Here
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
  public static void main(String args[])
  {
    try
    {
      /* Setup the command line parser */
      CmdLineParser parser = new CmdLineParser();
     
      /* Add our required options */
      CmdLineParser.Option keyfileOpt = parser.addStringOption('K', "keyfile");
      CmdLineParser.Option keyOpt = parser.addStringOption('k', "key");
      CmdLineParser.Option secretOpt = parser.addStringOption('s', "secret");
      CmdLineParser.Option bucketOpt = parser.addStringOption('b', "bucket");
      CmdLineParser.Option stdinOpt = parser.addBooleanOption('i', "stdin");
      CmdLineParser.Option stdoutOpt = parser.addBooleanOption('o', "stdout");
      CmdLineParser.Option listOpt = parser.addBooleanOption('l', "list");
      CmdLineParser.Option tagOpt = parser.addStringOption('t', "tag");
      CmdLineParser.Option deleteOpt = parser.addBooleanOption('d', "delete");
      CmdLineParser.Option pretendOpt = parser.addBooleanOption('p', "pretend");
      CmdLineParser.Option verboseOpt = parser.addBooleanOption('v', "verbose");
      CmdLineParser.Option versionOpt = parser.addBooleanOption('V', "version");
      CmdLineParser.Option fileOpt = parser.addBooleanOption('f', "file");
      CmdLineParser.Option sizeOpt = parser.addIntegerOption('z', "size");
      CmdLineParser.Option neverDieOpt = parser.addBooleanOption('n', "neverdie");
      CmdLineParser.Option debugOpt = parser.addBooleanOption("debug");
      CmdLineParser.Option helpOpt = parser.addBooleanOption('h', "help");
     
     
      /* Parse the command line */
      try
      {
        parser.parse(args);
      }
      catch(CmdLineParser.OptionException oe)
      {
        printUsage(oe.getMessage());
        return;
      }
     
      /* get the command line values */
      String keyfile = (String)parser.getOptionValue(keyfileOpt);
      String key = (String)parser.getOptionValue(keyOpt);
      String secret = (String)parser.getOptionValue(secretOpt);
      String bucket = (String)parser.getOptionValue(bucketOpt);
      String tag = (String)parser.getOptionValue(tagOpt);
      Boolean stdin = (Boolean)parser.getOptionValue(stdinOpt, Boolean.FALSE);
      Boolean stdout = (Boolean)parser.getOptionValue(stdoutOpt, Boolean.FALSE);
      Boolean list = (Boolean)parser.getOptionValue(listOpt, Boolean.FALSE);
      Boolean delete = (Boolean)parser.getOptionValue(deleteOpt, Boolean.FALSE);
      Boolean pretend = (Boolean)parser.getOptionValue(pretendOpt, Boolean.FALSE);
      Boolean verbose = (Boolean)parser.getOptionValue(verboseOpt, new Boolean(pretend));
      Boolean version = (Boolean)parser.getOptionValue(versionOpt, Boolean.FALSE);
      Boolean neverDie = (Boolean)parser.getOptionValue(neverDieOpt, Boolean.FALSE);
      Boolean useFile = (Boolean)parser.getOptionValue(fileOpt, Boolean.FALSE);
      Integer size = (Integer)parser.getOptionValue(sizeOpt);
      Boolean debug = (Boolean)parser.getOptionValue(debugOpt, Boolean.FALSE);
      Boolean help = (Boolean)parser.getOptionValue(helpOpt, Boolean.FALSE);
     
     
     
      /* Analyze the command line options, and execute accordingly */
      if (help)
View Full Code Here
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
     * @param args
     * @return
     * @throws IOException
     */
    protected String[] processForLearningMode(String[] args) throws IOException {
        CmdLineParser parser = new CmdLineParser();
        Option optLearn = parser.addBooleanOption('l', "learn");
        Option optHost = parser.addStringOption('h', "host");
        Option optPort = parser.addIntegerOption('p', "port");
        Option optUsername = parser.addStringOption('u', "username");
        Option optPassword = parser.addStringOption('P', "password");
        Option optPromptSize = parser.addIntegerOption("prompt-size");
       
        try {                                                                  
            parser.parse(args);                                                
        }                                                                      
        catch (CmdLineParser.OptionException e) {                            
            System.err.println(e.getMessage());                                
            printUsage();                                                      
            System.exit(2);                                                    
        }
       
        if (parser.getRemainingArgs().length != 1) {
            printUsage();                                                      
            System.exit(2);
        }
       
        if (((Boolean)parser.getOptionValue(optLearn, false)).booleanValue()) {
            String host = (String) parser.getOptionValue(optHost, "localhost");
            int port = ((Integer) parser.getOptionValue(optPort, Integer.valueOf(22))).intValue();
            String username = (String) parser.getOptionValue(optUsername);
            String password = (String) parser.getOptionValue(optPassword, "");
            setPromptSize(((Integer) parser.getOptionValue(optPromptSize, Integer.valueOf(10))).intValue());
           
            StreamConnection streamConnection = new DefaultStreamConnection();
            streamConnection.addStreamListener(this);
            streamConnection.connect(host, port, username, password);
            startRecording(parser.getRemainingArgs()[0], host, port, username, password);
            ConsoleReader reader = new ConsoleReader();
            Thread t = new Thread(reader);
            t.start();
            streamConnection.waitFor("asfdasfasfdSomeStringThatDoesntExistasdfasdf");
            endRecording();
            System.exit(0);
        }
       
        return parser.getRemainingArgs();
    }
View Full Code Here
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
        Reader in = null;
        String root;
        int options = CSSURLEmbedder.DATAURI_OPTION;
       
        //initialize command line parser
        CmdLineParser parser = new CmdLineParser();
        CmdLineParser.Option verboseOpt = parser.addBooleanOption('v', "verbose");
        CmdLineParser.Option helpOpt = parser.addBooleanOption('h', "help");
        CmdLineParser.Option charsetOpt = parser.addStringOption("charset");
        CmdLineParser.Option rootOpt = parser.addStringOption("root");
        CmdLineParser.Option outputFilenameOpt = parser.addStringOption('o', "output");
        CmdLineParser.Option mhtmlOpt = parser.addBooleanOption("mhtml");
        CmdLineParser.Option mhtmlRootOpt = parser.addStringOption("mhtmlroot");
        CmdLineParser.Option skipMissingOpt = parser.addBooleanOption("skip-missing");
        CmdLineParser.Option uriLengthOpt = parser.addIntegerOption("max-uri-length");
        CmdLineParser.Option imageSizeOpt = parser.addIntegerOption("max-image-size");
       
        try {
           
            //parse the arguments
            parser.parse(args);

            //figure out if the help option has been executed
            Boolean help = (Boolean) parser.getOptionValue(helpOpt);
            if (help != null && help.booleanValue()) {
                usage();
                System.exit(0);
            }
           
            //determine boolean options
            verbose = parser.getOptionValue(verboseOpt) != null;
           
            //check for charset
            charset = (String) parser.getOptionValue(charsetOpt);
            if (charset == null || !Charset.isSupported(charset)) {
                charset = System.getProperty("file.encoding");
                if (charset == null) {
                    charset = "UTF-8";
                }
                if (verbose) {
                    System.err.println("\n[INFO] Using charset " + charset);
                }
            }
         
            //get the file arguments
            String[] fileArgs = parser.getRemainingArgs();
            String inputFilename = null;
           
            //if no file is given, use stdin
            if (fileArgs.length == 0){
                in = new InputStreamReader(System.in, charset);
            } else {
                //only the first filename is used
                inputFilename = fileArgs[0];                    
                in = new InputStreamReader(new FileInputStream(inputFilename), charset);           
            }

            //determine if there's a maximum URI length
            int uriLength = CSSURLEmbedder.DEFAULT_MAX_URI_LENGTH;
            Integer maxUriLength = (Integer) parser.getOptionValue(uriLengthOpt);
            if (maxUriLength != null){
                uriLength = maxUriLength.intValue();
                if (uriLength < 0){
                    uriLength = 0;
                }
            }
           
            //maximum size allowed for image files
            int imageSize = 0;
            Integer imageSizeOption = (Integer) parser.getOptionValue(imageSizeOpt);
            if (imageSizeOption != null){
                imageSize = imageSizeOption.intValue();
                if (imageSize < 0){
                    imageSize = 0;
                }
            }

            //determine if MHTML mode is on
            boolean mhtml = parser.getOptionValue(mhtmlOpt) != null;
            if(mhtml){
                options = CSSURLEmbedder.MHTML_OPTION;
            }
            String mhtmlRoot = (String) parser.getOptionValue(mhtmlRootOpt);
            if (mhtml && mhtmlRoot == null){
                throw new Exception("Must use --mhtmlroot when using --mhtml.");
            }
           
            //are missing files ok?
            boolean skipMissingFiles = parser.getOptionValue(skipMissingOpt) != null;
            if(skipMissingFiles) {
                options = options | CSSURLEmbedder.SKIP_MISSING_OPTION;
            }
           
            CSSURLEmbedder embedder = new CSSURLEmbedder(in, options, verbose, uriLength, imageSize);           
            embedder.setMHTMLRoot(mhtmlRoot);
           
            //close in case writing to the same file
            in.close(); in = null;
           
            //get root for relative URLs
            root = (String) parser.getOptionValue(rootOpt);
            if(root == null){
           
                if (inputFilename != null) {
                    //no root specified, so get from input file
                    root = (new File(inputFilename)).getCanonicalPath();
                    root = root.substring(0, root.lastIndexOf(File.separator));               
                } else {
                    throw new Exception("Must use --root when not specifying a filename.");
                }
            }
           
            if (!root.endsWith(File.separator)){
                root += File.separator;
            }
           
            if (verbose){
                System.err.println("[INFO] Using '" + root + "' as root for relative file paths.");
            }
                                 
            //get output filename
            outputFilename = (String) parser.getOptionValue(outputFilenameOpt);           
            if (outputFilename == null) {
                if (verbose){
                    System.err.println("[INFO] No output file specified, defaulting to stdout.");
                }               
               
View Full Code Here
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
        String outputFilename = null;
        Writer out = null;
        String mimeType = null;
       
        //initialize command line parser
        CmdLineParser parser = new CmdLineParser();
        CmdLineParser.Option verboseOpt = parser.addBooleanOption('v', "verbose");
        CmdLineParser.Option mimeTypeOpt = parser.addStringOption('m', "mime");
        CmdLineParser.Option helpOpt = parser.addBooleanOption('h', "help");
        CmdLineParser.Option charsetOpt = parser.addStringOption("charset");
        CmdLineParser.Option outputFilenameOpt = parser.addStringOption('o', "output");
       
        try {
           
            //parse the arguments
            parser.parse(args);

            //figure out if the help option has been executed
            Boolean help = (Boolean) parser.getOptionValue(helpOpt);
            if (help != null && help.booleanValue()) {
                usage();
                System.exit(0);
            }
           
            //determine boolean options
            verbose = parser.getOptionValue(verboseOpt) != null;
           
            //check for charset
            charset = (String) parser.getOptionValue(charsetOpt);
           
            //check for MIME type
            mimeType = (String) parser.getOptionValue(mimeTypeOpt);

            //get the file arguments
            String[] fileArgs = parser.getRemainingArgs();
           
            //need to have at least one file
            if (fileArgs.length == 0){
                System.err.println("[ERROR] No files specified.");
                System.exit(1);
            }
           
            //only the first filename is used
            String inputFilename = fileArgs[0];           
                                 
            //get output filename
            outputFilename = (String) parser.getOptionValue(outputFilenameOpt);
           
            if (outputFilename == null) {
                if (verbose){
                    System.err.println("[INFO] No output file specified, defaulting to stdout.");
                }               
View Full Code Here
TOP

Related Classes of jargs.gnu.CmdLineParser

  • com.extjs.JSBuilder2
  • com.neophob.sematrix.cli.PixConClient
  • com.turn.ttorrent.cli.ClientMain
  • com.turn.ttorrent.cli.TorrentMain
  • com.turn.ttorrent.cli.TrackerMain
  • com.willerce.yabo.Yabo
  • com.yahoo.platform.yui.compressor.YUICompressor
  • edu.stanford.genetics.treeview.MainProgramArgs
  • edu.stanford.genetics.treeview.plugin.dendroview.DendroviewArgs
  • jwssbml.Convert
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.