package java.lang; import java.io.IOException; import java.io.OutputStream; import java.io.PrintStream; import ej.annotation.Nullable; /** * The System class contains several useful class fields and methods. It cannot be * instantiated. * *

* Among the facilities provided by the System class are standard input, standard * output, and error output streams; access to externally defined properties and environment * variables; and a utility method for quickly copying a portion of an array. */ public final class System { /** * The "standard" error output stream. This stream is already open and ready to accept output data. *

* Typically this stream corresponds to display output or another output destination specified by * the host environment or user. By convention, this output stream is used to display error messages * or other information that should come to the immediate attention of a user even if the principal * output stream, the value of the variable out, has been redirected to a file or other * destination that is typically not continuously monitored. */ public static final PrintStream err = new PrintStream(new OutputStream() { @Override public void write(int b) throws IOException { throw new RuntimeException(); } }); /** * The "standard" output stream. This stream is already open and ready to accept output data. * Typically this stream corresponds to display output or another output destination specified by * the host environment or user. *

* For simple stand-alone Java applications, a typical way to write a line of output data is: *

* *

	 * System.out.println(data)
	 *

* *

* See the println methods in class PrintStream. * * @see java.io.PrintStream#println() * @see java.io.PrintStream#println(boolean) * @see java.io.PrintStream#println(char) * @see java.io.PrintStream#println(char[]) * @see java.io.PrintStream#println(double) * @see java.io.PrintStream#println(float) * @see java.io.PrintStream#println(int) * @see java.io.PrintStream#println(long) * @see java.io.PrintStream#println(java.lang.Object) * @see java.io.PrintStream#println(java.lang.String) */ public static final PrintStream out = new PrintStream(new OutputStream() { @Override public void write(int b) throws IOException { throw new RuntimeException(); } }); private System() { // This class cannot be instantiated. throw new RuntimeException(); } /** * Copies an array from the specified source array, beginning at the specified position, to the * specified position of the destination array. A subsequence of array components are copied from * the source array referenced by src to the destination array referenced by * dest. The number of components copied is equal to the length argument. * The components at positions srcPos through srcPos+length-1 in the * source array are copied into positions destPos through * destPos+length-1, respectively, of the destination array. *

* If the src and dest arguments refer to the same array object, then the * copying is performed as if the components at positions srcPos through * srcPos+length-1 were first copied to a temporary array with length * components and then the contents of the temporary array were copied into positions * destPos through destPos+length-1 of the destination array. *

* If dest is null, then a NullPointerException is thrown. *

* If src is null, then a NullPointerException is thrown and * the destination array is not modified. *

* Otherwise, if any of the following is true, an ArrayStoreException is thrown and the * destination is not modified: *

The src argument refers to an object that is not an array. *
The dest argument refers to an object that is not an array. *
The src argument and dest argument refer to arrays whose component * types are different primitive types. *
The src argument refers to an array with a primitive component type and the * dest argument refers to an array with a reference component type. *
The src argument refers to an array with a reference component type and the * dest argument refers to an array with a primitive component type. *

* Otherwise, if any of the following is true, an IndexOutOfBoundsException is thrown * and the destination is not modified: *

The srcPos argument is negative. *
The destPos argument is negative. *
The length argument is negative. *
srcPos+length is greater than src.length, the length of the source * array. *
destPos+length is greater than dest.length, the length of the * destination array. *

* Otherwise, if any actual component of the source array from position srcPos through * srcPos+length-1 cannot be converted to the component type of the destination array * by assignment conversion, an ArrayStoreException is thrown. In this case, let * k be the smallest nonnegative integer less than length such that * src[srcPos+k] cannot be converted to the component type of the * destination array; when the exception is thrown, source array components from positions * srcPos through srcPos+k-1 will already have been * copied to destination array positions destPos through destPos+ * k-1 and no other positions of the destination array will have been modified. * (Because of the restrictions already itemized, this paragraph effectively applies only to the * situation where both arrays have component types that are reference types.) * * @param src * the source array. * @param srcPos * starting position in the source array. * @param dest * the destination array. * @param destPos * starting position in the destination data. * @param length * the number of array elements to be copied. * @exception IndexOutOfBoundsException * if copying would cause access of data outside array bounds. * @exception ArrayStoreException * if an element in the src array could not be stored into the * dest array because of a type mismatch. * @exception NullPointerException * if either src or dest is null. */ public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) { throw new RuntimeException(); } /** * Returns the current time in milliseconds. Note that while the unit of time of the return value is * a millisecond, the granularity of the value depends on the underlying operating system and may be * larger. For example, many operating systems measure time in units of tens of milliseconds. * *

* See the description of the class Date for a discussion of slight discrepancies that * may arise between "computer time" and coordinated universal time (UTC). * * @return the difference, measured in milliseconds, between the current time and midnight, January * 1, 1970 UTC. * @see java.util.Date */ public static long currentTimeMillis() { throw new RuntimeException(); } /** * Terminates the currently running Java Virtual Machine. The argument serves as a status code; by * convention, a nonzero status code indicates abnormal termination. *

* This method calls the exit method in class Runtime. This method never * returns normally. *

* The call System.exit(n) is effectively equivalent to the call:

* *

	 * Runtime.getRuntime().exit(n)
	 *

* *

* * @param status * exit status. * @throws SecurityException * if a security manager exists and its checkExit method doesn't allow exit * with the specified status. * @see java.lang.Runtime#exit(int) */ public static void exit(int status) { throw new RuntimeException(); } /** * Runs the garbage collector. *

* Calling the gc method suggests that the Java Virtual Machine expend effort toward * recycling unused objects in order to make the memory they currently occupy available for quick * reuse. When control returns from the method call, the Java Virtual Machine has made a best effort * to reclaim space from all discarded objects. *

* The call System.gc() is effectively equivalent to the call:

* *

	 * Runtime.getRuntime().gc()
	 *

* *

* * @see java.lang.Runtime#gc() */ public static void gc() { throw new RuntimeException(); } /** * Gets the system property indicated by the specified key. *

* First, if there is a security manager, its checkPropertyAccess method is called with * the key as its argument. This may result in a SecurityException. *

* First, if there is a security manager, its checkPropertyAccess method is called with * the key as its argument. *

* If there is no current set of system properties, a set of system properties is first created and * initialized in the same manner as for the getProperties method. * * @param key * the name of the system property. * @param def * a default value. * @return the string value of the system property, or the default value if there is no property * with that key. * * @exception SecurityException * if a security manager exists and its checkPropertyAccess method doesn't * allow access to the specified system property. * @exception NullPointerException * if key is null. * @exception IllegalArgumentException * if key is empty. */ public static String getProperty(String key, String def) { throw new RuntimeException(); } /** * Gets the system security interface. * * @return if a security manager has already been established for the current application, then that * security manager is returned; otherwise, null is returned. * @see #setSecurityManager */ @Nullable public static SecurityManager getSecurityManager() { throw new RuntimeException(); } /** * Returns the same hash code for the given object as would be returned by the default method * hashCode(), whether or not the given object's class overrides hashCode(). The hash code for the * null reference is zero. * * @param x * object for which the hashCode is to be calculated * @return the hashCode */ public static int identityHashCode(@Nullable Object x) { throw new RuntimeException(); } /** * Returns the current value of the running Java Virtual Machine's high-resolution time source, in * nanoseconds. * *

* This method can only be used to measure elapsed time and is not related to any other notion of * system or wall-clock time. The value returned represents nanoseconds since some fixed but * arbitrary origin time (perhaps in the future, so values may be negative). The same origin * is used by all invocations of this method in an instance of a Java virtual machine; other virtual * machine instances are likely to use a different origin. * *

* This method provides nanosecond precision, but not necessarily nanosecond resolution (that is, * how frequently the value changes) - no guarantees are made except that the resolution is at least * as good as that of {@link #currentTimeMillis()}. * *

* Differences in successive calls that span greater than approximately 292 years (2⁶³ * nanoseconds) will not correctly compute elapsed time due to numerical overflow. * *

* The values returned by this method become meaningful only when the difference between two such * values, obtained within the same instance of a Java virtual machine, is computed. * *

* For example, to measure how long some code takes to execute: * *

	 * {
	 * 	@code
	 * 	long startTime = System.nanoTime();
	 * 	// ... the code being measured ...
	 * 	long estimatedTime = System.nanoTime() - startTime;
	 * }
	 *

* *

* To compare two nanoTime values * *

	 * {@code
	 * long t0 = System.nanoTime();
	 * ...
	 * long t1 = System.nanoTime();}
	 *

* * one should use {@code t1 - t0 < 0}, not {@code t1 < t0}, because of the possibility of numerical * overflow. * * @return the current value of the running Java Virtual Machine's high-resolution time source, in * nanoseconds */ public static long nanoTime() { throw new RuntimeException(); } /** * Sets the System security. * *

* If there is a security manager already installed, this method first calls the security manager's * checkPermission method with a RuntimePermission("setSecurityManager") * permission to ensure it's ok to replace the existing security manager. This may result in * throwing a SecurityException. * *

* Otherwise, the argument is established as the current security manager. If the argument is * null and no security manager has been established, then no action is taken and the * method simply returns. * * @param s * the security manager. * @exception SecurityException * if the security manager has already been set and its checkPermission * method doesn't allow it to be replaced. * @see #getSecurityManager * @see SecurityManager#checkPermission * @see java.lang.RuntimePermission */ public static void setSecurityManager(@Nullable SecurityManager s) { throw new RuntimeException(); } }