@SuppressWarnings("rawtypes") private void cleanup(GantResult result, GantBinding binding) { if (result != null) { Class cls = GantMetaClass.class; try { Field methodsInvoked = cls.getDeclaredField("methodsInvoked"); methodsInvoked.setAccessible(true); Set methodsInvokedSet = (Set) methodsInvoked.get(cls); if (methodsInvokedSet != null) { methodsInvokedSet.clear(); } } catch (NoSuchFieldException e) { // ignore } catch (IllegalAccessException e) { // ignore } } System.setIn(originalIn); System.setOut(originalOut); GrailsPluginUtils.clearCaches(); Map variables = binding.getVariables(); Object pluginsSettingsObject = variables.get("pluginsSettings"); if (pluginsSettingsObject instanceof PluginBuildSettings) { ((PluginBuildSettings) pluginsSettingsObject).clearCache(); } GroovySystem.getMetaClassRegistry().removeMetaClass(GantBinding.class); GroovySystem.getMetaClassRegistry().removeMetaClass(Gant.class); }
private void setDefaultInputStream(GantBinding binding) { // Gant does not initialise the default input stream for // the Ant project, so we manually do it here. AntBuilder antBuilder = (AntBuilder) binding.getVariable("ant"); Project p = antBuilder.getAntProject(); try { System.setIn(originalIn); p.setInputHandler(new CommandLineInputHandler()); p.setDefaultInputStream(originalIn); } catch (NoSuchMethodError nsme) { // will only happen due to a bug in JRockit // note - the only approach that works is to loop through the public methods for (Method m : p.getClass().getMethods()) { if ("setDefaultInputStream".equals(m.getName()) && m.getParameterTypes().length == 1 && InputStream.class.equals(m.getParameterTypes()[0])) { try { m.invoke(p, originalIn); break; } catch (Exception e) { // shouldn't happen, but let it bubble up to the catch(Throwable) throw new RuntimeException(e); } } } } }
public static void main(String args[]) { try { System.setIn(new FileInputStream("vans.in")); System.setOut(new PrintStream("vans.out")); } catch (Throwable T_T) { } new vans().run(); }
private static void setStream(String in, String out) { try { System.setIn(new BufferedInputStream(new FileInputStream(in))); System.setOut(new PrintStream(out)); } catch (Exception e) { e.printStackTrace(); } }
public static void resetStream() { if (stdin != null && stdout != null) { in = null; out = null; System.setIn(stdin); System.setOut(stdout); } }
private void redirectIO() { // redirect std I/O to console and problems: // > System.out => console // > System.err => problems // > console => System.in System.setOut(consoleView.getOutputStream()); System.setErr(problemsView.getOutputStream()); // redirect input from console to System.in System.setIn(consoleView.getInputStream()); }
/** @param args */ public static void main(String[] args) throws Exception { File file = new File("input.txt"); if (file.exists()) { System.setIn(new BufferedInputStream(new FileInputStream("input.txt"))); } out = System.out; bw = new BufferedWriter(new PrintWriter(out)); // sc = new Scanner(System.in); br = new BufferedReader(new InputStreamReader(System.in)); C231 t = new C231(); t.solve(); bw.close(); }
public static void redirectStream() throws Exception { if (file != null) { stdin = System.in; stdout = System.out; if (!STDINPUT) { in = new FileInputStream(file + ".in"); System.setIn(in); } if (!STDOUT) { out = new PrintStream(new FileOutputStream(file + ".out")); System.setOut(out); } } }
public static void main(String... args) { System.setIn( new ByteArrayInputStream( "2\n5\n0 0\n1 0\n1 1\n1 2\n0 2\n6\n1.0 1.0\n30.91 8\n4.0 7.64\n21.12 6.0\n11.39 3.0\n5.31 11.0" .getBytes())); Scanner scanner = new Scanner(System.in); int t = scanner.nextInt(); for (int i = 0; i < t; i++) { int n = scanner.nextInt(); Coord[] towers = new Coord[n]; for (int j = 0; j < n; j++) { towers[j] = new Coord(scanner.nextDouble(), scanner.nextDouble()); } Arctic arctic = new Arctic(towers); arctic.minPower(0, new boolean[n], new double[n - 1]); System.out.printf("%.2f\n", arctic.min); } }
/** @param args */ public static void main(String[] args) throws Exception { File file = new File("B-small-practice.in"); if (file.exists()) { System.setIn(new BufferedInputStream(new FileInputStream(file))); } sc = new Scanner(System.in); FileWriter fw = new FileWriter(new File("output.txt")); out = new PrintWriter(fw); Bsmall b = new Bsmall(); int T = sc.nextInt(); int t = 1; while (t <= T) { out.print("Case #" + t + ": "); b.solve(); t++; } out.close(); fw.close(); }
/** @param args */ public static void main(String[] args) throws Exception { out = System.out; File file = new File("input.txt"); if (file.exists()) { System.setIn(new BufferedInputStream(new FileInputStream("input.txt"))); } sc = new Scanner(System.in); POJ3109 p = new POJ3109(); while (true) { try { N = sc.nextInt(); if (N == 0) { break; } } catch (Exception ex) { break; } p.solve(); } }
public static void main(String[] args) throws Exception { System.setIn(new BufferedInputStream(new FileInputStream("E.txt"))); new E().run(); }
private BuildResult doRun( final OutputListenerImpl outputListener, OutputListenerImpl errorListener, BuildListenerImpl listener) { // Capture the current state of things that we will change during execution InputStream originalStdIn = System.in; Properties originalSysProperties = new Properties(); originalSysProperties.putAll(System.getProperties()); File originalUserDir = new File(originalSysProperties.getProperty("user.dir")); Map<String, String> originalEnv = new HashMap<String, String>(System.getenv()); // Augment the environment for the execution System.setIn(getStdin()); processEnvironment.maybeSetProcessDir(getWorkingDir()); for (Map.Entry<String, String> entry : getEnvironmentVars().entrySet()) { processEnvironment.maybeSetEnvironmentVariable(entry.getKey(), entry.getValue()); } Map<String, String> implicitJvmSystemProperties = getImplicitJvmSystemProperties(); System.getProperties().putAll(implicitJvmSystemProperties); DefaultStartParameter parameter = new DefaultStartParameter(); parameter.setCurrentDir(getWorkingDir()); parameter.setShowStacktrace(ShowStacktrace.ALWAYS); CommandLineParser parser = new CommandLineParser(); DefaultCommandLineConverter converter = new DefaultCommandLineConverter(); converter.configure(parser); ParsedCommandLine parsedCommandLine = parser.parse(getAllArgs()); BuildLayoutParameters layout = converter.getLayoutConverter().convert(parsedCommandLine); Map<String, String> properties = new HashMap<String, String>(); new LayoutToPropertiesConverter().convert(layout, properties); converter.getSystemPropertiesConverter().convert(parsedCommandLine, properties); new PropertiesToStartParameterConverter().convert(properties, parameter); converter.convert(parsedCommandLine, parameter); DefaultGradleLauncherFactory factory = DeprecationLogger.whileDisabled( new Factory<DefaultGradleLauncherFactory>() { public DefaultGradleLauncherFactory create() { return (DefaultGradleLauncherFactory) GradleLauncher.getFactory(); } }); factory.addListener(listener); GradleLauncher gradleLauncher = factory.newInstance(parameter); gradleLauncher.addStandardOutputListener(outputListener); gradleLauncher.addStandardErrorListener(errorListener); try { return gradleLauncher.run(); } finally { // Restore the environment System.setProperties(originalSysProperties); processEnvironment.maybeSetProcessDir(originalUserDir); for (String envVar : getEnvironmentVars().keySet()) { String oldValue = originalEnv.get(envVar); if (oldValue != null) { processEnvironment.maybeSetEnvironmentVariable(envVar, oldValue); } else { processEnvironment.maybeRemoveEnvironmentVariable(envVar); } } factory.removeListener(listener); System.setIn(originalStdIn); } }
/** * Executes the requested Grails target. The "targetName" must match a known Grails script * provided by grails-scripts. * * @param targetName The name of the Grails target to execute. * @param args String of arguments to be passed to the executed Grails target. * @throws MojoExecutionException if an error occurs while attempting to execute the target. */ protected void runGrails(final String targetName, String args) throws MojoExecutionException { if (((lastArgs != null && lastArgs.equals(args)) || (lastArgs == null && args == null)) && lastTargetName != null && lastTargetName.equals(targetName)) return; lastArgs = args; lastTargetName = targetName; if (!alreadyLoaderClasspathForArtifact()) doOncePerArtifact(); else if (targetName.equals("War")) resolveClasspath(); // we have to get rid of the test rubbish getLog() .info( "Grails target: " + targetName + " raw args:" + args + " (pom says Grails Version is " + grailsVersion + ")"); InputStream currentIn = System.in; PrintStream currentOutput = System.out; try { RootLoader rootLoader = new RootLoader(addBinaryPluginWorkaround(classpath)); // see if log4j is there and if so, initialize it try { Class cls = rootLoader.loadClass("org.springframework.util.Log4jConfigurer"); invokeStaticMethod( cls, "initLogging", new Object[] {"classpath:grails-maven/log4j.properties"}); } catch (Exception ex) { getLog().info("No log4j available, good!"); } try { final DecentGrailsLauncher launcher = new DecentGrailsLauncher(rootLoader, grailsHomePath, basedir.getAbsolutePath()); launcher.setPlainOutput(true); /** * this collects the different dependency levels (compile, runtime, test) and puts them into * the correct arrays to pass through to the Grails script launcher. If using Maven, you * should *never* see an Ivy message and if you do, immediately stop your build, figure out * the incorrect dependency, delete the ~/.ivy2 directory and try again. */ Field settingsField = launcher.getClass().getDeclaredField("settings"); settingsField.setAccessible(true); configureBuildSettings( launcher, resolvedArtifacts, settingsField, rootLoader.loadClass("grails.util.BuildSettings"), args); syncAppVersion(); installGrailsPlugins( pluginDirectories, launcher, settingsField, rootLoader.loadClass("grails.util.AbstractBuildSettings")); // If the command is running in non-interactive mode, we // need to pass on the relevant argument. if (this.nonInteractive) { args = (args != null) ? "--non-interactive " + args : "--non-interactive "; } // consuming the standard output after execution via Maven. args = (args != null) ? "--plain-output " + args : "--plain-output"; args = (args != null) ? "--stacktrace " + args : "--stacktrace"; args = (args != null) ? "--verboseCompile " + args : "--verboseCompile"; if (env == null) System.clearProperty("grails.env"); else System.setProperty("grails.env", env); getLog() .info( "grails -Dgrails.env=" + (env == null ? "dev" : env) + " " + targetName.toLowerCase() + " " + args); int retval; if ("true".equals(System.getProperty("print.grails.settings")) || "ideaprintprojectsettings".equalsIgnoreCase(targetName)) { printIntellijIDEASettings(launcher, settingsField, pluginArtifacts); } else { if ("interactive".equals(targetName)) retval = launcher.launch("", "", env); else retval = launcher.launch(targetName, args, env); if (retval != 0) { throw new MojoExecutionException("Grails returned non-zero value: " + retval); } } } catch (final MojoExecutionException ex) { // Simply rethrow it. throw ex; } catch (final Exception ex) { getLog().error(ex); throw new MojoExecutionException("Unable to start Grails", ex); } rootLoader = null; } catch (MalformedURLException mfe) { throw new MojoExecutionException("Unable to start Grails", mfe); } finally { System.setIn(currentIn); System.setOut(currentOutput); } System.gc(); // try and help with memory issues }