|
|
Chapter 11. The java.io PackageThe java.io package contains a relatively large number of classes, but, as you can see from Figure 11-1 and Figure 11-2, the classes form a fairly structured hierarchy. Most of the package consists of byte streams--subclasses of InputStream or OutputStream and (in Java 1.1) character streams--subclasses of Reader or Writer. Each of these stream types has a specific purpose, and, despite its size, java.io is a straightforward package to understand and to use. Before we consider the stream classes in the package, let's examine the important non-stream classes. File represents a file or directory name in a system-independent way and provides methods for listing directories, querying file attributes, and renaming and deleting files. FilenameFilter is an interface that defines a method that accepts or rejects specified filenames. It is used by java.awt.FileDialog and File to specify what types of files should be included in directory listings. RandomAccessFile allows you to read from or write to arbitrary locations of a file. Often, though, you'll prefer sequential access to a file and should use one of the stream classes. InputStream and OutputStream are abstract classes that define methods for reading and writing bytes. Their subclasses allow bytes to be read from and written to a variety of sources and sinks. FileInputStream and FileOutputStream read from and write to files. ByteArrayInputStream and ByteArrayOutputStream read from and write to an array of bytes in memory. PipedInputStream reads bytes from a PipedOutputStream, and PipedOutputStream writes bytes to a PipedInputStream. These classes work together to implement a pipe for communication between threads. FilterInputStream and FilterOutputStream are special; they filter input and output bytes. When you create a FilterInputStream, you specify an InputStream for it to filter. When you call the read() method of a FilterInputStream, it calls the read() method of its InputStream, processes the bytes it reads, and returns the filtered bytes. Similarly, when you create a FilterOutputStream, you specify an OutputStream to be filtered. Calling the write() method of a FilterOutputStream causes it to process your bytes in some way and then pass those filtered bytes to the write() method of its OutputStream. Figure 11-1. The java.io packageFigure 11-2. The exception classes of the java.io packageFilterInputStream and FilterOutputStream do not perform any filtering themselves; this is done by their subclasses. BufferedInputStream and BufferedOutputStream provide input and output buffering and can increase I/O efficiency. DataInputStream reads raw bytes from a stream and interprets them in various binary formats. It has various methods to read primitive Java data types in their standard binary formats. DataOutputStream allows you to write Java primitive data types in binary format. In Java 1.1 and later, the byte streams I just described are complemented by an analogous set of character input and output streams. Reader is the superclass of all character input streams, and Writer is the superclass of all character output streams. These character streams supersede the byte streams for all textual I/O. They are more efficient than the byte streams, and they correctly handle the conversion between local encodings and Unicode text, making them invaluable for internationalized programs. Most of the Reader and Writer streams have obvious byte-stream analogs. BufferedReader is a commonly used stream; it provides buffering for efficiency and also has a readLine() method to read a line of text at a time. PrintWriter is another very common stream; its methods allow output of a textual representation of any primitive Java type or of any object (via the object's toString() method). The ObjectInputStream and ObjectOutputStream classes are special. These byte-stream classes are new as of Java 1.1 and are part of the Object Serialization API.
This class is a FilterInputStream that provides input data buffering; efficiency is increased by reading in a large amount of data and storing it in an internal buffer. When data is requested, it is usually available from the buffer. Thus, most calls to read data do not actually have to read data from a disk, network, or other slow source. Create a BufferedInputStream by specifying the InputStream that is to be buffered in the call to the constructor. See also BufferedReader.
Hierarchy: Object-->java.io.InputStream-->FilterInputStream-->BufferedInputStream
This class is a FilterOutputStream that provides output data buffering; output efficiency is increased by storing values to be written in a buffer and actually writing them out only when the buffer fills up or when the flush() method is called. Create a BufferedOutputStream by specifying the OutputStream that is to be buffered in the call to the constructor. See also BufferedWriter.
Hierarchy: Object-->java.io.OutputStream-->FilterOutputStream-->BufferedOutputStream
This class applies buffering to a character input stream, thereby improving the efficiency of character input. You create a BufferedReader by specifying some other character input stream from which it is to buffer input. (You can also specify a buffer size at this time, although the default size is usually fine.) Typically, you use this sort of buffering with a FileReader or InputStreamReader. BufferedReader defines the standard set of Reader methods and provides a readLine() method that reads a line of text (not including the line terminator) and returns it as a String. BufferedReader is the character-stream analog of BufferedInputStream. It also provides a replacement for the deprecated readLine() method of DataInputStream, which did not properly convert bytes into characters.
Hierarchy: Object-->Reader-->BufferedReader Subclasses: LineNumberReader Returned By: javax.servlet.ServletRequest.getReader()
This class applies buffering to a character output stream, improving output efficiency by coalescing many small write requests into a single larger request. You create a BufferedWriter by specifying some other character output stream to which it sends its buffered and coalesced output. (You can also specify a buffer size at this time, although the default size is usually satisfactory.) Typically, you use this sort of buffering with a FileWriter or OutputStreamWriter. BufferedWriter defines the standard write(), flush(), and close() methods all output streams define, but it adds a newLine() method that outputs the platform-dependent line separator (usually a newline character, a carriage-return character, or both) to the stream. BufferedWriter is the character-stream analog of BufferedOutputStream.
Hierarchy: Object-->Writer-->BufferedWriter
This class is a subclass of InputStream in which input data comes from a specified array of byte values. This is useful when you want to read data in memory as if it were coming from a file, pipe, or socket. Note that the specified array of bytes is not copied when a ByteArrayInputStream is created. See also CharArrayReader.
Hierarchy: Object-->java.io.InputStream-->ByteArrayInputStream
This class is a subclass of OutputStream in which output data is stored in an internal byte array. The internal array grows as necessary and can be retrieved with toByteArray() or toString(). The reset() method discards any data currently stored in the internal array and stores data from the beginning again. See also CharArrayWriter.
Hierarchy: Object-->java.io.OutputStream-->ByteArrayOutputStream
This class is a character input stream that uses a character array as the source of the characters it returns. You create a CharArrayReader by specifying the character array (or portion of an array) it is to read from. CharArrayReader defines the usual Reader methods and supports the mark() and reset() methods. Note that the character array you pass to the CharArrayReader() constructor is not copied. This means that changes you make to the elements of the array after you create the input stream affect the values read from the array. CharArrayReader is the character-array analog of ByteArrayInputStream and is similar to StringReader.
Hierarchy: Object-->Reader-->CharArrayReader
This class is a character output stream that uses an internal character array as the destination of characters written to it. When you create a CharArrayWriter, you may optionally specify an initial size for the character array, but you do not specify the character array itself; this array is managed internally by the CharArrayWriter and grows as necessary to accommodate all the characters written to it. The toString() and toCharArray() methods return a copy of all characters written to the stream, as a string and an array of characters, respectively. CharArrayWriter defines the standard write(), flush(), and close() methods all Writer subclasses define. It also defines a few other useful methods. size() returns the number of characters that have been written to the stream. reset() resets the stream to its initial state, with an empty character array; this is more efficient than creating a new CharArrayWriter. Finally, writeTo() writes the contents of the internal character array to some other specified character stream. CharArrayWriter is the character-stream analog of ByteArrayOutputStream and is quite similar to StringWriter.
Hierarchy: Object-->Writer-->CharArrayWriter
Signals an error when converting bytes to characters or vice versa.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->CharConversionException
This interface defines the methods required for streams that can read Java primitive data types in a machine-independent binary format. It is implemented by DataInputStream and RandomAccessFile. See DataInputStream for more information on the methods.
Implementations: java.io.DataInputStream, ObjectInput, RandomAccessFile Passed To: java.io.DataInputStream.readUTF(), java.rmi.server.UID.read()
This class is a type of FilterInputStream that allows you to read binary representations of Java primitive data types in a portable way. Create a DataInputStream by specifying the InputStream that is to be filtered in the call to the constructor. DataInputStream reads only primitive Java types; use ObjectInputStream to read object values. Many of the methods read and return a single Java primitive type, in binary format, from the stream. readUnsignedByte() and readUnsignedShort() read unsigned values and return them as int values, since unsigned byte and short types are not supported in Java. read() reads data into an array of bytes, blocking until at least some data is available. By contrast, readFully() reads data into an array of bytes, but blocks until all requested data becomes available. skipBytes() blocks until the specified number of bytes have been read and discarded. readLine() reads characters from the stream until it encounters a newline, a carriage return, or a newline/carriage return pair. The returned string is not terminated with a newline or carriage return. This method is deprecated as of Java 1.1; see BufferedReader for an alternative. readUTF() reads a string of Unicode text encoded in a slightly modified version of the UTF-8 transformation format. UTF-8 is an ASCII-compatible encoding of Unicode characters that is often used for the transmission and storage of Unicode text. This class uses a modified UTF-8 encoding that never contains embedded null characters.
Hierarchy: Object-->java.io.InputStream-->FilterInputStream-->java.io.DataInputStream(DataInput) Passed To: javax.swing.text.html.parser.DTD.read()
This interface defines the methods required for streams that can write Java primitive data types in a machine-independent binary format. It is implemented by DataOutputStream and RandomAccessFile. See DataOutputStream for more information on the methods.
Implementations: java.io.DataOutputStream, ObjectOutput, RandomAccessFile Passed To: java.rmi.server.UID.write()
This class is a subclass of FilterOutputStream that allows you to write Java primitive data types in a portable binary format. Create a DataOutputStream by specifying the OutputStream that is to be filtered in the call to the constructor. DataOutputStream has methods that output only primitive types; use ObjectOutputStream to output object values. Many of this class's methods write a single Java primitive type, in binary format, to the output stream. write() writes a single byte, an array, or a subarray of bytes. flush() forces any buffered data to be output. size() returns the number of bytes written so far. writeUTF() outputs a Java string of Unicode characters using a slightly modified version of the UTF-8 transformation format. UTF-8 is an ASCII-compatible encoding of Unicode characters that is often used for the transmission and storage of Unicode text. Except for the writeUTF() method, this class is used for binary output of data. Textual output should be done with PrintWriter (or PrintStream in Java 1.0).
Hierarchy: Object-->java.io.OutputStream-->FilterOutputStream-->java.io.DataOutputStream(DataOutput)
An IOException that signals the end-of-file.
 The writeExternal() and readExternal() methods should be implemented to write and read object data in some arbitrary format, using the methods of the DataOutput and DataInput interfaces. Externalizable objects must serialize their own fields and are also responsible for serializing the fields of their superclasses. Most objects do not need to define a custom output format and can use the Serializable interface instead of Externalizable for serialization.
Hierarchy: (Externalizable(Serializable)) Implementations: java.awt.datatransfer.DataFlavor, java.rmi.server.RemoteRef
This class supports a platform-independent definition of file and directory names. It also provides methods to list the files in a directory; check the existence, readability, writeability, type, size, and modification time of files and directories; make new directories; rename files and directories; delete files and directories; and create and delete temporary and lock files. The constants defined by this class are the platform-dependent directory and path-separator characters, available as a String and a char. getName() returns the name of the File with any directory names omitted. getPath() returns the full name of the file, including the directory name. getParent() and getParentFile() return the directory that contains the File; the only difference between the two methods is that one returns a String, while the other returns a File. isAbsolute() tests whether the File is an absolute specification. If not, getAbsolutePath() returns an absolute filename created by appending the relative filename to the current working directory. getAbsoluteFile() returns the equivalent absolute File object. getCanonicalPath() and getCanonicalFile() are similar methods: they return an absolute filename or File object that has been converted to its system-dependent canonical form. This can be useful when comparing two File objects to see if they refer to the same file or directory. exists(), canWrite(), canRead(), isFile(), isDirectory(), and isHidden() perform the obvious tests on the specified File. length() returns the length of the file. lastModified() returns the modification time of the file (which should be used for comparison with other file times only and not interpreted as any particular time format). setLastModified() allows the modification time to be set; setReadOnly() makes a file or directory read-only. list() returns the names of all entries in a directory that are not rejected by an optional FilenameFilter. listFiles() returns an array of File objects that represent all entries in a directory not rejected by an optional FilenameFilter or FileFilter. listRoots() returns an array of File objects representing all root directories on the system. On Unix systems, for example, there is typically only one root, /. On Windows systems, however, there is a different root for each drive letter: c:\, d:\, and e:\, for example. mkdir() creates a directory, and mkdirs() creates all the directories in a File specification. renameTo() renames a file or directory; delete() deletes a file or directory. Prior to Java 1.2, the File class doesn't provide any way to create a file; that task is accomplished typically with FileOutputStream. As of Java 1.2, however, two special-purpose file creation methods have been added. The static createTempFile() method returns a File object that refers to a newly created empty file with a unique name that begins with the specified prefix (which must be at least three characters long) and ends with the specified suffix. One version of this method creates the file in a specified directory, and the other creates it in the system temporary directory. Applications can use temporary files for any purpose without worrying about overwriting files belonging to other applications. The other file-creation method of Java 1.2 is createNewFile(). This instance method attempts to create a new, empty file with the name specified by the File object. If it succeeds, it returns true. However, if the file already exists, it returns false. createNewFile() works atomically, and is therefore useful for file locking and other mutual-exclusion schemes. When working with createTempFile() or createNewFile(), consider using deleteOnExit() to request that the files be deleted when the Java VM exits normally.
Hierarchy: Object-->File(Comparable,Serializable) Passed To: Too many methods to list. Returned By: Too many methods to list.
This class is a platform-independent representation of a low-level handle to an open file or socket. The static in, out, and err variables are FileDescriptor objects that represent the standard input, output, and error streams, respectively. There is no public constructor method to create a FileDescriptor object. You can obtain one with the getFD() method of FileInputStream, FileOutputStream, or RandomAccessFile.
Passed To: FileInputStream.FileInputStream(), FileOutputStream.FileOutputStream(), FileReader.FileReader(), FileWriter.FileWriter(), SecurityManager.{checkRead(), checkWrite()} Returned By: FileInputStream.getFD(), FileOutputStream.getFD(), RandomAccessFile.getFD(), java.net.DatagramSocketImpl.getFileDescriptor(), java.net.SocketImpl.getFileDescriptor() Type Of: FileDescriptor.{err, in, out}, java.net.DatagramSocketImpl.fd, java.net.SocketImpl.fd
This interface defines an accept() method that filters a list of files. You can list the contents of a directory by calling the listFiles() method of the File object that represents the desired directory. If you want a filtered listing, such as a listing of files but not subdirectories or a listing of files whose names end in .class, you can pass a FileFilter object to listFiles(). For each entry in the directory, a File object is passed to the accept() method. If accept() returns true, that File is included in the return value of listFiles(). If accept() returns false, that entry is not included in the listing. FileFilter is new in Java 1.2. Use FilenameFilter if compatibility with previous releases of Java is required or if you prefer to filter filenames (i.e., String objects) rather than File objects.
Passed To: File.listFiles()
This class is a subclass of InputStream that reads bytes from a file specified by name or by a File or FileDescriptor object. read() reads a byte or array of bytes from the file. It returns -1 when the end-of-file has been reached. To read binary data, you typically use this class in conjunction with a BufferedInputStream and DataInputStream. To read text, you typically use it with an InputStreamReader and BufferedReader. Call close() to close the file when input is no longer needed.
Hierarchy: Object-->java.io.InputStream-->FileInputStream
This interface defines the accept() method that must be implemented by any object that filters filenames (i.e., selects a subset of filenames from a list of filenames). There are no standard FilenameFilter classes implemented by Java, but objects that implement this interface are used by the java.awt.FileDialog object and the File.list() method. A typical FilenameFilter object might check that the specified File represents a file (not a directory), is readable (and possibly writable as well), and that its name ends with some desired extension.
Passed To: java.awt.FileDialog.setFilenameFilter(), java.awt.peer.FileDialogPeer.setFilenameFilter(), File.{list(), listFiles()} Returned By: java.awt.FileDialog.getFilenameFilter()
An IOException that signals that a specified file cannot be found.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->FileNotFoundException Thrown By: FileInputStream.FileInputStream(), FileOutputStream.FileOutputStream(), FileReader.FileReader(), RandomAccessFile.RandomAccessFile()
This class is a subclass of OutputStream that writes data to a file specified by name or by a File or FileDescriptor object. write() writes a byte or array of bytes to the file. To write binary data, you typically use this class in conjunction with a BufferedOutputStream and a DataOutputStream. To write text, you typically use it with a PrintWriter, BufferedWriter and an OutputStreamWriter. Use close() to close a FileOutputStream when no further output will be written to it.
Hierarchy: Object-->java.io.OutputStream-->FileOutputStream
This class is a java.security.Permission that governs access to the local filesystem. A FilePermission has a name, or target, which specifies what file or files it pertains to, and a comma-separated list of actions that may be performed on the file or files. The supported actions are "read", "write", "delete", and "execute". Read and write permission are required by any methods that read or write a file. Delete permission is required by File.delete(), and execute permission is required by Runtime.exec(). The name of a FilePermission may be as simple as a file or directory name. FilePermission also supports the use of certain wildcards, however, to specify a permission that applies to more than one file. If the name of the FilePermission is a directory name followed by "/*" ("\*" on Windows platforms), it specifies all files in the named directory. If the name is a directory name followed by "/-" ("\-" on Windows), it specifies all files in the directory, and, recursively, all files in all subdirectories. A "*" alone specifies all files in the current directory, and a "-" alone specifies all files in or beneath the current directory. Finally, the special name "<<ALL FILES>>" matches all files anywhere in the filesystem. Applications do not need to use this class directly. Programmers writing system-level code and system administrators configuring security policies may need to use it, however. Be very careful when granting any types of FilePermission. Restricting access (especially write access) to files is one of the cornerstones of the Java security model with regard to untrusted code.
Hierarchy: Object-->java.security.Permission(java.security.Guard,Serializable)-->FilePermission(Serializable)
FileReader is a convenience subclass of InputStreamReader that is useful when you want to read text (as opposed to binary data) from a file. You create a FileReader by specifying the file to be read in any of three possible forms. The FileReader constructor internally creates a FileInputStream to read bytes from the specified file and uses the functionality of its superclass, InputStreamReader, to convert those bytes from characters in the local encoding to the Unicode characters used by Java. Because FileReader is a trivial subclass of InputStreamReader, it does not define any read() methods or other methods of its own. Instead, it inherits all its methods from its superclass. If you want to read Unicode characters from a file that uses some encoding other than the default encoding for the locale, you must explicitly create your own InputStreamReader to perform the byte-to-character conversion.
Hierarchy: Object-->Reader-->InputStreamReader-->FileReader
FileWriter is a convenience subclass of OutputStreamWriter that is useful when you want to write text (as opposed to binary data) to a file. You create a FileWriter by specifying the file to be written to and, optionally, whether the data should be appended to the end of an existing file instead of overwriting that file. The FileWriter class creates an internal FileOutputStream to write bytes to the specified file and uses the functionality of its superclass, OutputStreamWriter, to convert the Unicode characters written to the stream into bytes using the default encoding of the default locale. (If you want to use an encoding other than the default, you cannot use FileWriter; in that case you must create your own OutputStreamWriter and FileOutputStream.) Because FileWriter is a trivial subclass of OutputStreamWriter, it does not define any methods of its own, but simply inherits them from its superclass.
Hierarchy: Object-->Writer-->OutputStreamWriter-->FileWriter
This class provides method definitions required to filter data obtained from the InputStream specified when the FilterInputStream is created. It must be subclassed to perform some sort of filtering operation and cannot be instantiated directly. See the subclasses BufferedInputStream, DataInputStream, and PushbackInputStream.
Hierarchy: Object-->java.io.InputStream-->FilterInputStream Subclasses: BufferedInputStream, java.io.DataInputStream, LineNumberInputStream, PushbackInputStream, java.security.DigestInputStream, java.util.zip.CheckedInputStream, java.util.zip.InflaterInputStream, javax.crypto.CipherInputStream, javax.swing.ProgressMonitorInputStream
This class provides method definitions required to filter the data to be written to the OutputStream specified when the FilterOutputStream is created. It must be subclassed to perform some sort of filtering operation and may not be instantiated directly. See the subclasses BufferedOutputStream and DataOutputStream.
Hierarchy: Object-->java.io.OutputStream-->FilterOutputStream Subclasses: BufferedOutputStream, java.io.DataOutputStream, PrintStream, java.security.DigestOutputStream, java.util.zip.CheckedOutputStream, java.util.zip.DeflaterOutputStream, javax.crypto.CipherOutputStream
This abstract class is intended to act as a superclass for character input streams that read data from some other character input stream, filter it in some way, and then return the filtered data when a read() method is called. FilterReader is declared abstract so that it cannot be instantiated. But none of its methods are themselves abstract: they all simply call the requested operation on the input stream passed to the FilterReader() constructor. If you were allowed to instantiate a FilterReader, you'd find that it is a null filter (i.e., it simply reads characters from the specified input stream and returns them without any kind of filtering). Because FilterReader implements a null filter, it is an ideal superclass for classes that want to implement simple filters but do not want to override all the methods of Reader. In order to create your own filtered character input stream, you should subclass FilterReader and override both its read() methods to perform the desired filtering operation. Note that you can implement one of the read() methods in terms of the other, and thus only implement the filtration once. Recall that the other read() methods defined by Reader are implemented in terms of these methods, so you do not need to override those. In some cases, you may need to override other methods of FilterReader and provide methods or constructors that are specific to your subclass. FilterReader is the character-stream analog to FilterInputStream.
Hierarchy: Object-->Reader-->FilterReader Subclasses: PushbackReader
This abstract class is intended to act as a superclass for character output streams that filter the data written to them before writing it to some other character output stream. FilterWriter is declared abstract so that it cannot be instantiated. But none of its methods are themselves abstract: they all simply invoke the corresponding method on the output stream that was passed to the FilterWriter constructor. If you were allowed to instantiate a FilterWriter object, you'd find that it acts as a null filter (i.e., it simply passes the characters written to it along, without any filtration). Because FilterWriter implements a null filter, it is an ideal superclass for classes that want to implement simple filters without having to override all of the methods of Writer. In order to create your own filtered character output stream, you should subclass FilterWriter and override all its write() methods to perform the desired filtering operation. Note that you can implement two of the write() methods in terms of the third and thus implement your filtering algorithm only once. In some cases, you may want to override other Writer methods and add other methods or constructors that are specific to your subclass. FilterWriter is the character-stream analog of FilterOutputStream.
Hierarchy: Object-->Writer-->FilterWriter
This abstract class is the superclass of all input streams. It defines the basic input methods all input stream classes provide.read() reads a single byte or an array (or subarray) of bytes. It returns the byte read, the number of bytes read, or -1 if the end-of-file has been reached. skip() skips a specified number of bytes of input. available() returns the number of bytes that can be read without blocking. close() closes the input stream and frees up any system resources associated with it. The stream should not be used after close() has been called. If markSupported() returns true for a given InputStream, that stream supports mark() and reset() methods. mark() marks the current position in the input stream so that reset() can return to that position (as long as no more than the specified number of bytes have been read between the calls to mark() and reset()). See also Reader.
Subclasses: ByteArrayInputStream, FileInputStream, FilterInputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream, javax.servlet.ServletInputStream, org.omg.CORBA.portable.InputStream Passed To: Too many methods to list. Returned By: Too many methods to list. Type Of: FilterInputStream.in, System.in
This class is a character input stream that uses a byte input stream as its data source. It reads bytes from a specified InputStream and translates them into Unicode characters according to a particular platform- and locale-dependent character encoding. This is an important internationalization feature in Java 1.1 and later. InputStreamReader supports the standard Reader methods. It also has a getEncoding() method that returns the name of the encoding being used to convert bytes to characters. When you create an InputStreamReader, you specify an InputStream from which the InputStreamReader is to read bytes and, optionally, the name of the character encoding used by those bytes. If you do not specify an encoding name, the InputStreamReader uses the default encoding for the default locale, which is usually the correct thing to do.
Hierarchy: Object-->Reader-->InputStreamReader Subclasses: FileReader
An IOException that signals that an input or output operation was interrupted. The bytesTransferred field contains the number of bytes read or written before the operation was interrupted.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->InterruptedIOException
Signals that the serialization mechanism has encountered one of several possible problems with the class of an object that is being serialized or deserialized. The classname field should contain the name of the class in question, and the getMessage() method is overridden to return this class name with the message.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->InvalidClassException
This exception should be thrown by the validateObject() method of an object that implements the ObjectInputValidation interface when a deserialized object fails an input validation test for any reason.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->InvalidObjectException Thrown By: java.awt.font.TextAttribute.readResolve(), ObjectInputStream.registerValidation(), ObjectInputValidation.validateObject(), java.text.AttributedCharacterIterator.Attribute.readResolve()
Signals that an exceptional condition has occurred during input or output. This class has several more specific subclasses. See EOFException, FileNotFoundException, InterruptedIOException, and UTFDataFormatException.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException Subclasses: CharConversionException, EOFException, FileNotFoundException, InterruptedIOException, ObjectStreamException, SyncFailedException, UnsupportedEncodingException, UTFDataFormatException, java.net.MalformedURLException, java.net.ProtocolException, java.net.SocketException, java.net.UnknownHostException, java.net.UnknownServiceException, java.rmi.RemoteException, java.util.zip.ZipException, javax.swing.text.ChangedCharSetException Passed To: java.awt.print.PrinterIOException.PrinterIOException() Returned By: java.awt.print.PrinterIOException.getIOException() Thrown By: Too many methods to list.
This class is a FilterInputStream that keeps track of the number of lines of data that have been read. getLineNumber() returns the current line number; setLineNumber() sets the line number of the current line. Subsequent lines are numbered starting from that number. This class is deprecated as of Java 1.1 because it does not properly convert bytes to characters. Use LineNumberReader instead.
Hierarchy: Object-->java.io.InputStream-->FilterInputStream-->LineNumberInputStream
This class is a character input stream that keeps track of the number of lines of text that have been read from it. It supports the usual Reader methods and also the readLine() method introduced by its superclass. In addition to these methods, you can call getLineNumber() to query the number of lines set so far. You can also call setLineNumber() to set the line number for the current line. Subsequent lines are numbered sequentially from this specified starting point. This class is a character-stream analog to LineNumberInputStream, which has been deprecated as of Java 1.1.
Hierarchy: Object-->Reader-->BufferedReader-->LineNumberReader
This exception is thrown in several circumstances. It indicates that the invoked method was not invoked at the right time or in the correct context. Typically, it means that an ObjectOutputStream or ObjectInputStream is not currently active and therefore the requested operation cannot be performed.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->NotActiveException Thrown By: ObjectInputStream.{defaultReadObject(), readFields(), registerValidation()}
Signals that an object cannot be serialized. It is thrown when serialization is attempted on an instance of a class that does not implement the Serializable interface. Note that it is also thrown when an attempt is made to serialize a Serializable object that refers to (or contains) an object that is not Serializable. A subclass of a class that is Serializable can prevent itself from being serialized by throwing this exception from its writeObject() and/or readObject() methods.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->NotSerializableException
This interface extends the DataInput interface and adds methods for deserializing objects and reading bytes and arrays of bytes.
Hierarchy: (ObjectInput(DataInput)) Implementations: ObjectInputStream Passed To: java.awt.datatransfer.DataFlavor.readExternal(), Externalizable.readExternal(), java.rmi.server.ObjID.read() Returned By: java.rmi.server.RemoteCall.getInputStream()
ObjectInputStream deserializes objects, arrays, and other values from a stream that was previously created with an ObjectOutputStream. The readObject() method deserializes objects and arrays (which should then be cast to the appropriate type); various other methods read primitive data values from the stream. Note that only objects that implement the Serializable or Externalizable interface can be serialized and deserialized. A class may implement its own private readObject(ObjectInputStream) method to customize the way it is deserialized. If you define such a method, there are several ObjectInputStream methods you can use to help you deserialize the object. defaultReadObject() is the easiest. It reads the content of the object just as an ObjectInputStream would normally do. If you wrote additional data before or after the default object contents, you should read that data before or after calling defaultReadObject(). When working with multiple versions or implementations of a class, you may have to deserialize a set of fields that do not match the fields of your class. In this case, give your class a static field named serialPersistentFields whose value is an array of ObjectStreamField objects that describe the fields to be deserialized. If you do this, your readObject() method can call readFields() to read the specified fields from the stream and return them in a ObjectInputStream.GetField object. See ObjectStreamField and ObjectInputStream.GetField for more details. Finally, you can call registerValidation() from a custom readObject() method. This method registers an ObjectInputValidation object (typically the object being deserialized) to be notified when a complete tree of objects has been deserialized, and the original call to the readObject() method of the ObjectInputStream is about to return to its caller. The remaining methods include miscellaneous stream-manipulation methods and several protected methods for use by subclasses that want to customize the deserialization behavior of ObjectInputStream.
Hierarchy: Object-->java.io.InputStream-->ObjectInputStream(ObjectInput(DataInput),ObjectStreamConstants) Passed To: java.beans.beancontext.BeanContextServicesSupport.bcsPreDeserializationHook(), java.beans.beancontext.BeanContextSupport.{bcsPreDeserializationHook(), deserialize(), readChildren()}, javax.swing.text.StyleContext.{readAttributes(), readAttributeSet()}
This class holds the values of named fields read by an ObjectInputStream. It gives the programmer precise control over the deserialization process and is typically used when implementing an object with a set of fields that do not match the set of fields (and the serialization stream format) of the original implementation of the object. This class allows the implementation of a class to change without breaking serialization compatibility. In order to use the GetField class, your class must implement a private readObject() method that is responsible for custom deserialization. Typically, when using the GetField class, you have also specified an array of ObjectStreamField objects as the value of a private static field named serialPersistentFields. This array specifies the names and types of all fields expected to be found when reading from a serialization stream. If there is no serialPersistantField field, the array of ObjectStreamField objects is created from the actual fields (excluding static and transient fields) of the class. Within the readObject() method of your class, call the readFields() method of ObjectInputStream(). This method reads the values of all fields from the stream and stores them in an ObjectInputStream.GetField object that it returns. This GetField object is essentially a mapping from field names to field values, and you can extract the values of whatever fields you need in order to restore the proper state of the object being deserialized. The various get() methods return the values of named fields of specified types. Each method takes a default value as an argument, in case no value for the named field was present in the serialization stream. (This can happen when deserializing an object written by an earlier version of the class, for example.) Use the defaulted() method to determine whether the GetField object contains a value for the named field. If this method returns true, the named field had no value in the stream, so the get() method of the GetField object has to return the specified default value. The getObjectStreamClass() method of a GetField object returns the ObjectStreamClass object for the object being deserialized. This ObjectStreamClass can obtain the array of ObjectStreamField objects for the class. See also ObjectOutputStream.PutField
Returned By: ObjectInputStream.readFields()
A class implements this interface and defines the validateObject() method in order to validate itself when it and all the objects it depends on have been completely deserialized from an ObjectInputStream. The validateObject() method is only invoked, however, if the object is passed to ObjectInputStream.registerValidation(); this must be done from the readObject() method of the object. Note that if an object is deserialized as part of a larger object graph, its validateObject() method is not invoked until the entire graph is read, and the original call to ObjectInputStream.readObject() is about to return. validateObject() should throw an InvalidObjectException if the object fails validation. This stops object serialization, and the original call to ObjectInputStream.readObject() terminates with the InvalidObjectException exception.
Passed To: ObjectInputStream.registerValidation()
This interface extends the DataOutput interface and adds methods for serializing objects and writing bytes and arrays of bytes.
Hierarchy: (ObjectOutput(DataOutput)) Implementations: ObjectOutputStream Passed To: java.awt.datatransfer.DataFlavor.writeExternal(), Externalizable.writeExternal(), ObjectOutputStream.PutField.write(), java.rmi.server.ObjID.write(), java.rmi.server.RemoteRef.getRefClass() Returned By: java.rmi.server.RemoteCall.{getOutputStream(), getResultStream()}
The ObjectOutputStream serializes objects, arrays, and other values to a stream. The writeObject() method serializes an object or array, and various other methods write primitive data values to the stream. Note that only objects that implement the Serializable or Externalizable interface can be serialized. A class that wants to customize the way instances are serialized should declare a private writeObject(ObjectOutputStream) method. This method is invoked when an object is being serialized and can use several additional methods of ObjectOutputStream. defaultWriteObject() performs the same serialization that would happen if no writeObject() method existed. An object can call this method to serialize itself and then use other methods of ObjectOutputStream to write additional data to the serialization stream. The class must define a matching readObject() method to read that additional data, of course. When working with multiple versions or implementations of a class, you may have to serialize a set of fields that do not precisely match the fields of your class. In this case, give your class a static field named serialPersistentFields whose value is an array of ObjectStreamField objects that describe the fields to be serialized. In your writeObject() method, call putFields() to obtain an ObjectOutputStream.PutField object. Store field names and values into this object, and then call writeFields() to write them out to the serialization stream. See ObjectStreamField and ObjectOutputStream.PutField for further details. The remaining methods of ObjectOutputStream are miscellaneous stream-manipulation methods and protected methods for use by subclasses that want to customize its serialization behavior.
Hierarchy: Object-->java.io.OutputStream-->ObjectOutputStream(ObjectOutput(DataOutput),ObjectStreamConstants) Passed To: java.awt.AWTEventMulticaster.{save(), saveInternal()}, java.beans.beancontext.BeanContextServicesSupport.bcsPreSerializationHook(), java.beans.beancontext.BeanContextSupport.{bcsPreSerializationHook(), serialize(), writeChildren()}, javax.swing.text.StyleContext.{writeAttributes(), writeAttributeSet()}
This class holds values of named fields and allows them to be written to an ObjectOutputStream during the process of object serialization. It gives the programmer precise control over the serialization process and is typically used when the set of fields defined by a class do not match the set of fields (and the serialization stream format) defined by the original implementation of the class. In other words, ObjectOutputStream.PutField allows the implementation of a class to change without breaking serialization compatibility. In order to use the PutField class, you typically define a private static serialPersistentFields field that refers to an array of ObjectStreamField objects. This array defines the set of fields written to the ObjectOutputStream, and therefore defines the serialization format. If you do not declare a serialPersistentFields field, the set of fields is all fields of the class, excluding static and transient fields. In addition to the serialPersistentFields field, your class must also define a private writeObject() method that is responsible for the custom serialization of your class. In this method, call the putFields() method of ObjectOutputStream to obtain an ObjectOutputStream.PutField object. Once you have this object, use its various put() methods to specify the names and values of the field to be written out. The set of named fields should match those specified by serialPersistentFields. You may specify the fields in any order; the PutField class is responsible for writing them out in the correct order. Once you have specified the values of all fields, call the write() method of your PutField object in order to write the field values out to the serialization stream. To reverse this custom serialization process, see ObjectInputStream.GetField.
Returned By: ObjectOutputStream.putFields()
This class represents a class that is being serialized. An ObjectStreamClass object contains the name of a class, its unique version identifier, and the name and type of the fields that constitute the serialization format for the class. getSerialVersionUID() returns a unique version identifier for the class. It returns either the value of the private serialVersionUID field of the class or a computed value that is based upon the public API of the class. In Java 1.2 and later, getFields() returns an array of ObjectStreamField objects that represent the names and types of the fields of the class to be serialized. getField() returns a single ObjectStreamField object that represents a single named field. By default, these methods use all the fields of a class except those that are static or transient. However, this default set of fields can be overridden by declaring a private serialPersistentFields field in the class. The value of this field should be the desired array of ObjectStreamField objects. ObjectStreamClass class does not have a constructor; you should use the static lookup() method to obtain an ObjectStreamClass object for a given Class object. The forClass() instance method performs the opposite operation; it returns the Class object that corresponds to a given ObjectStreamClass. Most applications never need to use this class.
Hierarchy: Object-->ObjectStreamClass(Serializable) Passed To: ObjectInputStream.resolveClass(), ObjectOutputStream.writeClassDescriptor() Returned By: ObjectInputStream.readClassDescriptor(), ObjectInputStream.GetField.getObjectStreamClass(), ObjectStreamClass.lookup()
This interface defines various constants used by the Java object-serialization mechanism. Two important constants are PROTOCOL_VERSION_1 and PROTOCOL_VERSION_2, which specify the version of the serialization protocol to use. In Java 1.2, you can pass either of these values to the useProtocolVersion() method of an ObjectOutputStream. By default, Java 1.2 uses Version 2 of the protocol, and Java 1.1 uses Version 1 when serializing objects. Java 1.2 can deserialize objects written using either version of the protocol, as can Java 1.1.7 and later. If you want to serialize an object so that it can be read by versions of Java prior to Java 1.1.7, use PROTOCOL_VERSION_1. The other constants defined by this interface are low-level values used by the serialization protocol. You do not need to use them unless you are reimplementing the serialization mechanism yourself.
Implementations: ObjectInputStream, ObjectOutputStream
This class is the superclass of a number of more specific exception types that may be raised in the process of serializing and deserializing objects with the ObjectOutputStream and ObjectInputStream classes.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException Subclasses: InvalidClassException, InvalidObjectException, NotActiveException, NotSerializableException, OptionalDataException, StreamCorruptedException, WriteAbortedException Thrown By: java.awt.color.ICC_Profile.readResolve(), java.security.cert.Certificate.writeReplace(), java.security.cert.Certificate.CertificateRep.readResolve()
This class represents a named field of a specified type (i.e., a specified Class). When a class serializes itself by writing a set of fields that are different from the fields it uses in its own implementation, it defines the set of fields to be written with an array of ObjectStreamField objects. This array should be the value of a private static field named serialPersistentFields. The methods of this class are used internally by the serialization mechanism and are not typically used elsewhere. See also ObjectOutputStream.PutField and ObjectInputStream.GetField.
Hierarchy: Object-->ObjectStreamField(Comparable) Returned By: ObjectStreamClass.{getField(), getFields()} Type Of: ObjectStreamClass.NO_FIELDS
Thrown by the readObject() method of an ObjectInputStream when it encounters primitive type data where it expects object data. Despite the exception name, this data is not optional, and object deserialization is stopped.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->OptionalDataException Thrown By: ObjectInputStream.{readObject(), readObjectOverride()}
This abstract class is the superclass of all output streams. It defines the basic output methods all output stream classes provide. write() writes a single byte or an array (or subarray) of bytes. flush() forces any buffered output to be written. close() closes the stream and frees up any system resources associated with it. The stream may not be used once close() has been called. See also Writer.
Subclasses: ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, PipedOutputStream, javax.servlet.ServletOutputStream, org.omg.CORBA.portable.OutputStream Passed To: Too many methods to list. Returned By: Process.getOutputStream(), Runtime.getLocalizedOutputStream(), java.net.Socket.getOutputStream(), java.net.SocketImpl.getOutputStream(), java.net.URLConnection.getOutputStream(), java.rmi.server.LogStream.getOutputStream() Type Of: FilterOutputStream.out
This class is a character output stream that uses a byte output stream as the destination for its data. When characters are written to an OutputStreamWriter, it translates them into bytes according to a particular locale- and/or platform-specific character encoding and writes those bytes to the specified OutputStream. This is a very important internationalization feature in Java 1.1 and later. OutputStreamWriter supports the usual Writer methods. It also has a getEncoding() method that returns the name of the encoding being used to convert characters to bytes. When you create an OutputStreamWriter, specify the OutputStream to which it writes bytes and, optionally, the name of the character encoding that should be used to convert characters to bytes. If you do not specify an encoding name, the OutputStreamWriter uses the default encoding of the default locale, which is usually the correct thing to do.
Hierarchy: Object-->Writer-->OutputStreamWriter Subclasses: FileWriter
This class is an InputStream that implements one half of a pipe and is useful for communication between threads. A PipedInputStream must be connected to a PipedOutputStream object, which may be specified when the PipedInputStream is created or with the connect() method. Data read from a PipedInputStream object is received from the PipedOutputStream to which it is connected. See InputStream for information on the low-level methods for reading data from a PipedInputStream. A FilterInputStream can provide a higher-level interface for reading data from a PipedInputStream.
Hierarchy: Object-->java.io.InputStream-->PipedInputStream Passed To: PipedOutputStream.{connect(), PipedOutputStream()}
This class is an OutputStream that implements one half of a pipe and is useful for communication between threads. A PipedOutputStream must be connected to a PipedInputStream, which may be specified when the PipedOutputStream is created or with the connect() method. Data written to the PipedOutputStream is available for reading on the PipedInputStream. See OutputStream for information on the low-level methods for writing data to a PipedOutputStream. A FilterOutputStream can provide a higher-level interface for writing data to a PipedOutputStream.
Hierarchy: Object-->java.io.OutputStream-->PipedOutputStream Passed To: PipedInputStream.{connect(), PipedInputStream()}
PipedReader is a character input stream that reads characters from a PipedWriter character output stream to which it is connected. PipedReader implements one half of a pipe and is useful for communication between two threads of an application. A PipedReader cannot be used until it is connected to a PipedWriter object, which may be passed to the PipedReader() constructor or to the connect() method. PipedReader inherits most of the methods of its superclass. See Reader for more information. PipedReader is the character-stream analog of PipedInputStream.
Hierarchy: Object-->Reader-->PipedReader Passed To: PipedWriter.{connect(), PipedWriter()}
PipedWriter is a character output stream that writes characters to the PipedReader character input stream to which it is connected. PipedWriter implements one half of a pipe and is useful for communication between two threads of an application. A PipedWriter cannot be used until it is connected to a PipedReader object, which may be passed to the PipedWriter() constructor, or to the connect() method. PipedWriter inherits most of the methods of its superclass. See Writer for more information. PipedWriter is the character-stream analog of PipedOutputStream.
Hierarchy: Object-->Writer-->PipedWriter Passed To: PipedReader.{connect(), PipedReader()}
This class is a FilterOutputStream that implements a number of methods for displaying textual representations of Java primitive data types. The print() methods output standard textual representations of each data type. The println() methods do the same and follow the representations with newlines. Each method converts a Java primitive type to a String representation and outputs the resulting string. When an Object is passed to a print() or println(), it is converted to a String by calling its toString() method. PrintStream is the OutputStream type that makes it easiest to output text. As such, it is the most commonly used of the output streams. The System.out variable is a PrintStream. Note that in Java 1.0 this class does not handle Unicode characters correctly; it discards the top 8 bits of all 16-bit characters and thus works only with Latin-1 (ISO8859-1) characters. Although this problem has been fixed as of Java 1.1, PrintStream has been superseded by PrintWriter as of Java 1.1. The constructors of this class have been deprecated, but the class itself has not, because it is still used by the System.out and System.err standard output streams. PrintStream, and its PrintWriter replacement, output textual representations of Java data types. Use DataOutputStream to output binary representations of data.
Hierarchy: Object-->java.io.OutputStream-->FilterOutputStream-->PrintStream Subclasses: java.rmi.server.LogStream Passed To: Too many methods to list. Returned By: java.rmi.server.LogStream.getDefaultStream(), java.rmi.server.RemoteServer.getLog(), java.sql.DriverManager.getLogStream(), javax.swing.DebugGraphics.logStream() Type Of: System.{err, out}
This class is a character output stream that implements a number of print() and println() methods that output textual representations of primitive values and objects. When you create a PrintWriter object, you specify a character or byte output stream that it should write its characters to and, optionally, whether the PrintWriter stream should be automatically flushed whenever println() is called. If you specify a byte output stream as the destination, the PrintWriter() constructor automatically creates the necessary OutputStreamWriter object to convert characters to bytes using the default encoding. PrintWriter implements the normal write(), flush(), and close() methods all Writer subclasses define. It is more common to use the higher-level print() and println() methods, each of which converts its argument to a string before outputting it. println() can also terminate the line (and optionally flush the buffer) after printing its argument. The methods of PrintWriter never throw exceptions. Instead, when errors occur, they set an internal flag you can check by calling checkError(). checkError() first flushes the internal stream and then returns true if any exception has occurred while writing values to that stream. Once an error has occurred on a PrintWriter object, all subsequent calls to checkError() return true; there is no way to reset the error flag. PrintWriter is the character stream analog to PrintStream, which it supersedes. You can usually trivially replace any PrintStream objects in a program with PrintWriter objects. This is particularly important for internationalized programs. The only valid remaining use for the PrintStream class is for the System.out and System.err standard output streams. See PrintStream for details.
Hierarchy: Object-->Writer-->PrintWriter Passed To: Too many methods to list. Returned By: java.sql.DriverManager.getLogWriter(), javax.servlet.ServletResponse.getWriter(), javax.sql.ConnectionPoolDataSource.getLogWriter(), javax.sql.DataSource.getLogWriter(), javax.sql.XADataSource.getLogWriter()
This class is a FilterInputStream that implements a one-byte pushback buffer or, as of Java 1.1, a pushback buffer of a specified length. The unread() methods push bytes back into the stream; these bytes are the first ones read by the next call to a read() method. This class is sometimes useful when writing parsers. See also PushbackReader.
Hierarchy: Object-->java.io.InputStream-->FilterInputStream-->PushbackInputStream
This class is a character input stream that uses another input stream as its input source and adds the ability to push characters back onto the stream. This feature is often useful when writing parsers. When you create a PushbackReader stream, you specify the stream to be read from and, optionally, the size of the pushback buffer (i.e., the number of characters that may be pushed back onto the stream or unread). If you do not specify a size for this buffer, the default size is one character. PushbackReader inherits or overrides all standard Reader methods and adds three unread() methods that push a single character, an array of characters, or a portion of an array of characters back onto the stream. This class is the character stream analog of PushbackInputStream.
Hierarchy: Object-->Reader-->FilterReader-->PushbackReader
This class allows you to read and write arbitrary bytes, text, and primitive Java data types from or to any specified location in a file. Because this class provides random, rather than sequential, access to files, it is neither a subclass of InputStream nor of OutputStream, but provides an entirely independent method for reading and writing data from or to files. RandomAccessFile implements the same interfaces as DataInputStream and DataOutputStream, and thus defines the same methods for reading and writing data as those classes do. The seek() method provides random access to the file; it is used to select the position in the file where data should be read or written. The mode argument to the constructor methods should be "r" for a file that is to be read-only or "rw" for a file that is to be written (and perhaps read as well).
Hierarchy: Object-->RandomAccessFile(DataInput,DataOutput)
This abstract class is the superclass of all character input streams. It is an analog to InputStream, which is the superclass of all byte input streams. Reader defines the basic methods that all character output streams provide. read() returns a single character or an array (or subarray) of characters, blocking if necessary; it returns -1 if the end of the stream has been reached. ready() returns true if there are characters available for reading. If ready() returns true, the next call to read() is guaranteed not to block. close() closes the character input stream. skip() skips a specified number of characters in the input stream. If markSupported() returns true, mark() marks a position in the stream and, if necessary, creates a look-ahead buffer of the specified size. Future calls to reset() restore the stream to the marked position if they occur within the specified look-ahead limit. Note that not all stream types support this mark-and-reset functionality. To create a subclass of Reader, you need only implement the three-argument version of read() and the close() method. Most subclasses implement additional methods, however.
Subclasses: BufferedReader, CharArrayReader, FilterReader, InputStreamReader, PipedReader, StringReader Passed To: Too many methods to list. Returned By: java.awt.datatransfer.DataFlavor.getReaderForText(), java.sql.Clob.getCharacterStream(), java.sql.ResultSet.getCharacterStream(), java.sql.SQLInput.readCharacterStream() Type Of: FilterReader.in
This class provides a way of seamlessly concatenating the data from two or more input streams. It provides an InputStream interface to a sequence of InputStream objects. Data is read from the streams in the order in which the streams are specified. When the end of one stream is reached, data is automatically read from the next stream. This class might be useful, for example, when implementing an include file facility for a parser of some sort.
Hierarchy: Object-->java.io.InputStream-->SequenceInputStream
The Serializable interface defines no methods or constants. A class should implement this interface simply to indicate that it allows itself to be serialized and deserialized with ObjectOutputStream.writeObject() and ObjectInputStream.readObject(). Objects that need special handling during serialization or deserialization may implement one or both of the following methods. Note, however, that these methods are not part of the Serializable interface: private void writeObject(java.io.ObjectOutputStream out) throws IOException; private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException; Typically, the writeObject() method performs any necessary cleanup or preparation for serialization, invokes the defaultWriteObject() method of the ObjectOutputStream to serialize the non-transient fields of the class, and optionally writes any additional data that is required. Similarly, the readObject() method typically invokes the defaultReadObject() method of the ObjectInputStream, reads any additional data written by the corresponding writeObject() method, and performs any extra initialization required by the object. The readObject() method may also register an ObjectInputValidation object to validate the object once it is completely deserialized.
Implementations: Too many classes to list. Passed To: java.security.SignedObject.SignedObject(), javax.crypto.SealedObject.SealedObject(), javax.jms.ObjectMessage.setObject(), javax.jms.Session.createObjectMessage(), org.omg.CORBA.Any.insert_Value(), org.omg.CORBA.DataOutputStream.write_Value(), org.omg.CORBA.DynAny.insert_val(), org.omg.CORBA.StreamingPolicy.marshal(), org.omg.CORBA.StringValueHelper.write_value(), org.omg.CORBA.ValueBaseHelper.{insert(), write()}, org.omg.CORBA.ValueBaseHolder.ValueBaseHolder(), org.omg.CORBA.WStringValueHelper.write_value(), org.omg.CORBA.portable.BoxedValueHelper.write_value() Returned By: java.beans.beancontext.BeanContextSupport.getChildSerializable(), javax.jms.ObjectMessage.getObject(), org.omg.CORBA.Any.extract_Value(), org.omg.CORBA.DataInputStream.read_Value(), org.omg.CORBA.DynAny.get_val(), org.omg.CORBA.StreamingPolicy.unmarshal(), org.omg.CORBA.StringValueHelper.read_value(), org.omg.CORBA.ValueBaseHelper.{extract(), read()}, org.omg.CORBA.WStringValueHelper.read_value(), org.omg.CORBA.portable.BoxedValueHelper.read_value(), org.omg.CORBA.portable.ValueFactory.read_value() Type Of: org.omg.CORBA.ValueBaseHolder.value
This class is a java.security.Permission that governs the use of certain sensitive features of serialization. SerializablePermission objects have a name, or target, but do not have an action list. The name "enableSubclassImplementation" represents permission to serialize and deserialize objects using subclasses of ObjectOutputStream and ObjectInputStream. This capability is protected by a permission because malicious code can define object stream subclasses that incorrectly serialize and deserialize objects. The only other name supported by SerializablePermission is "enableSubstitution", which represents permission for one object to be substituted for another during serialization or deserialization. The ObjectOutputStream.enableReplaceObject() and ObjectInputStream.enableResolveObject() methods require a permission of this type. Applications never need to use this class. Programmers writing system-level code may use it, and system adminstrators configuring security policies should be familiar with it.
Hierarchy: Object-->java.security.Permission(java.security.Guard,Serializable)-->java.security.BasicPermission(Serializable)-->SerializablePermission Type Of: ObjectStreamConstants.{SUBCLASS_IMPLEMENTATION_PERMISSION, SUBSTITUTION_PERMISSION}
Signals that the data stream being read by an ObjectInputStream has been corrupted and does not contain valid serialized object data.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->StreamCorruptedException Thrown By: ObjectInputStream.{ObjectInputStream(), readStreamHeader()}, java.rmi.server.RemoteCall.getResultStream()
This class performs lexical analysis of a specified input stream and breaks the input into tokens. It can be extremely useful when writing simple parsers. nextToken() returns the next token in the stream; this is either one of the constants defined by the class (which represent end-of-file, end-of-line, a parsed floating-point number, and a parsed word) or a character value. pushBack() pushes the token back onto the stream, so that it is returned by the next call to nextToken(). The public variables sval and nval contain the string and numeric values (if applicable) of the most recently read token. They are applicable when the returned token is TT_WORD or TT_NUMBER. lineno() returns the current line number. The remaining methods allow you to specify how tokens are recognized. wordChars() specifies a range of characters that should be treated as parts of words. whitespaceChars() specifies a range of characters that serve to delimit tokens. ordinaryChars() and ordinaryChar() specify characters that are never part of tokens and should be returned as-is. resetSyntax() makes all characters ordinary. eolIsSignificant() specifies whether end-of-line is significant. If so, the TT_EOL constant is returned for end-of-lines; otherwise, they are treated as whitespace. commentChar() specifies a character that begins a comment that lasts until the end of the line. No characters in the comment are returned. slashStarComments() and slashSlashComments() specify whether the StreamTokenizer should recognize C- and C++-style comments. If so, no part of the comment is returned as a token. quoteChar() specifies a character used to delimit strings. When a string token is parsed, the quote character is returned as the token value, and the body of the string is stored in the sval variable. lowerCaseMode() specifies whether TT_WORD tokens should be converted to all lowercase characters before being stored in sval. parseNumbers() specifies that the StreamTokenizer should recognize and return double-precision floating-point number tokens.
This class is a subclass of InputStream in which input bytes come from the characters of a specified String object. This class does not correctly convert the characters of a StringBuffer into bytes and is deprecated as of Java 1.1. Use StringReader instead to convert characters into bytes or use ByteArrayInputStream to read bytes from an array of bytes.
Hierarchy: Object-->java.io.InputStream-->StringBufferInputStream
This class is a character input stream that uses a String object as the source of the characters it returns. When you create a StringReader, you must specify the String to read from. StringReader defines the normal Reader methods and supports mark() and reset(). If reset() is called before mark() has been called, the stream is reset to the beginning of the specified string. StringReader is a character stream analog to StringBufferInputStream, which is deprecated as of Java 1.1. StringReader is also similar to CharArrayReader.
Hierarchy: Object-->Reader-->StringReader
This class is a character output stream that uses an internal StringBuffer object as the destination of the characters written to the stream. When you create a StringWriter, you may optionally specify an initial size for the StringBuffer, but you do not specify the StringBuffer itself; it is managed internally by the StringWriter and grows as necessary to accommodate the characters written to it. StringWriter defines the standard write(), flush(), and close() methods all Writer subclasses define, as well as two methods to obtain the characters that have been written to the stream's internal buffer. toString() returns the contents of the internal buffer as a String, and getBuffer() returns the buffer itself. Note that getBuffer() returns a reference to the actual internal buffer, not a copy of it, so any changes you make to the buffer are reflected in subsequent calls to toString(). StringWriter is quite similar to CharArrayWriter, but does not have a byte-stream analog.
Hierarchy: Object-->Writer-->StringWriter
Signals that a call to FileDescriptor.sync() did not complete successfully.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->SyncFailedException Thrown By: FileDescriptor.sync()
Signals that a requested character encoding is not supported by the current Java Virtual Machine.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->UnsupportedEncodingException Thrown By: ByteArrayOutputStream.toString(), InputStreamReader.InputStreamReader(), OutputStreamWriter.OutputStreamWriter(), String.{getBytes(), String()}
An IOException that signals that a malformed UTF-8 string has been encountered by a class that implements the DataInput interface. UTF-8 is an ASCII-compatible transformation format for Unicode characters that is often used to store and transmit Unicode text.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->UTFDataFormatException
Thrown when reading a stream of data that is incomplete because an exception was thrown while it was being written. The detail field may contain the exception that terminated the output stream. The getMessage() method has been overridden to include the message of this detail exception, if any.
Hierarchy: Object-->Throwable(Serializable)-->Exception-->IOException-->ObjectStreamException-->WriteAbortedException
This abstract class is the superclass of all character output streams. It is an analog to OutputStream, which is the superclass of all byte output streams. Writer defines the basic write(), flush(), and close() methods all character output streams provide. The five versions of the write() method write a single character, a character array or subarray, or a string or substring to the destination of the stream. The most general version of this method--the one that writes a specified portion of a character array--is abstract and must be implemented by all subclasses. By default, the other write() methods are implemented in terms of this abstract one. The flush() method is another abstract method all subclasses must implement. It should force any output buffered by the stream to be written to its destination. If that destination is itself a character or byte output stream, it should invoke the flush() method of the destination stream as well. The close() method is also abstract. A subclass must implement this method so that it flushes and then closes the current stream and also closes whatever destination stream it is connected to. Once the stream is closed, any future calls to write() or flush() should throw an IOException.
Subclasses: BufferedWriter, CharArrayWriter, FilterWriter, OutputStreamWriter, PipedWriter, PrintWriter, StringWriter Passed To: Too many methods to list. Returned By: javax.swing.text.AbstractWriter.getWriter() Type Of: FilterWriter.out, PrintWriter.out Copyright © 2001 O'Reilly & Associates. All rights reserved. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|


Create New Internal User
View All Internal User
Access Logs
PII
Logout
Employee ID
First Name
Last Name
View Employee.
Name
Position
Office
Extn.


Class: Aws::Redshift::Types::GetClusterCredentialsMessage
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb |
Overview
The request parameters to get cluster credentials.
Constant Summary
Instance Attribute Summary
-
#auto_create ⇒ Boolean
rw
Create a database user with the name specified for the user named in
DbUser
if one does not exist. -
#cluster_identifier ⇒ String
rw
The unique identifier of the cluster that contains the database for which you are requesting credentials.
-
#custom_domain_name ⇒ String
rw
The custom domain name for the cluster credentials.
-
#db_groups ⇒ Array<String>
rw
A list of the names of existing database groups that the user named in
DbUser
will join for the current session, in addition to any group memberships for an existing user. -
#db_name ⇒ String
rw
The name of a database that
DbUser
is authorized to log on to. -
#db_user ⇒ String
rw
The name of a database user.
-
#duration_seconds ⇒ Integer
rw
The number of seconds until the returned temporary password expires.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#auto_create ⇒ Boolean
(rw)
Create a database user with the name specified for the user named in
DbUser
if one does not exist.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#cluster_identifier ⇒ String
(rw)
The unique identifier of the cluster that contains the database for which you are requesting credentials. This parameter is case sensitive.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#custom_domain_name ⇒ String
(rw)
The custom domain name for the cluster credentials.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#db_groups ⇒ Array
<String
> (rw)
A list of the names of existing database groups that the user named
in DbUser
will join for the current session, in addition to any
group memberships for an existing user. If not specified, a new user
is added only to PUBLIC.
Database group name constraints
Must be 1 to 64 alphanumeric characters or hyphens
Must contain only lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.
First character must be a letter.
Must not contain a colon ( : ) or slash ( / ).
Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#db_name ⇒ String
(rw)
The name of a database that DbUser
is authorized to log on to. If
DbName
is not specified, DbUser
can log on to any existing
database.
Constraints:
Must be 1 to 64 alphanumeric characters or hyphens
Must contain uppercase or lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.
First character must be a letter.
Must not contain a colon ( : ) or slash ( / ).
Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#db_user ⇒ String
(rw)
The name of a database user. If a user name matching DbUser
exists
in the database, the temporary user credentials have the same
permissions as the existing user. If DbUser
doesn't exist in the
database and Autocreate
is True
, a new user is created using the
value for DbUser
with PUBLIC permissions. If a database user
matching the value for DbUser
doesn't exist and Autocreate
is
False
, then the command succeeds but the connection attempt will
fail because the user doesn't exist in the database.
For more information, see CREATE USER in the Amazon Redshift Database Developer Guide.
Constraints:
Must be 1 to 64 alphanumeric characters or hyphens. The user name can't be
PUBLIC
.Must contain uppercase or lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.
First character must be a letter.
Must not contain a colon ( : ) or slash ( / ).
Cannot be a reserved word. A list of reserved words can be found in Reserved Words in the Amazon Redshift Database Developer Guide.
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end
#duration_seconds ⇒ Integer
(rw)
The number of seconds until the returned temporary password expires.
Constraint: minimum 900, maximum 3600.
Default: 900
# File 'gems/aws-sdk-redshift/lib/aws-sdk-redshift/types.rb', line 6392
class GetClusterCredentialsMessage < Struct.new( :db_user, :db_name, :cluster_identifier, :duration_seconds, :auto_create, :db_groups, :custom_domain_name) SENSITIVE = [] include Aws::Structure end


Task OPS
Task List
{% for memidx, member in ([(0, "you")] + current_user.members ) %}
{% endfor %}
Assigned to {{ member }}
-
{% for taskId, task in current_user.getTasks(memidx) %}
- {{ task }} {% endfor %}


Here's a quick list to all the demos. More details in the
repository’s README
.
Animation Worklet
Parallax Scrolling
Twitter Header
Twitter Hidey Bar
Spring Timing
Sticky Spring
Expando effect
Swipe-to-Action and Scroll-to-Section
Paint Worklet
Circle in Textarea
Ripple
Border Color
Checkerboard
Parameterized Checkerboard
Diamond-shaped DOM elements
QR code generator
Border Radius Reverse
Layout Worklet
Masonry
Relative
Properties & Values
Animating a custom property


Lprotct email analyzer Download attachment Launch desktop client
Attachment:
Refresh the email page/tab


setup staking
Start Block
End Block
Setup
Fee Id
Setup fee id
LEV Id
Setup lev id
Stake Tokens
LEV Tokens
Provide Access
Stake
Add Owner
New Owner
Add a new Owner
Send Fee to stake
Fee Tokens
Send Fee
Set operator
Operator
Set
Get Events
Set Minter
Update Fee For Current StakingInterval
Redeem Lev And Fee
Restart Staking
flip Calculated


GoldFish
loyalty
Shop
My Diaries
My account
Logout
Shop
My Diaries
My account
Logout
menu
{{userName}}'s Diaries
Welcome to your DiaryBoard !
Add a new Diary
{{diary.nameDiary}}
{{diary.dateCreation}}
{{goal.id}} : {{goal.nameGoal}}
{{entry.id}} : {{entry.content}} - {{entry.dateCreation}}
Add Goal
Create a Goal
Name*
Descritpion*
{{result}}
Add Entry
Create an Entry
Descritpion*
{{result}}
Create a new Diary
Name*
Description*
{{result}}


  Long doggo thicc puggo, smol.  Smol borking doggo with a long snoot for pats ur givin me a spook very taste wow doge doggorino, lotsa pats the neighborhood pupper shoober. Dat tungg tho puggorino pupper long water shoob heckin good boys and girls, long doggo very hand that feed shibe extremely cuuuuuute.  Floofs heckin doggo waggy wags long doggo, big ol blep you are doin me a concern. Most angery pupper I have ever seen pupperino shoober, long doggo.
I love blankets, similar to this doggo.


Home
Saved
Analysis
Contact
About
Take Flight in Your Rocket Ship
Become the Master of all Space
Stock Symbol
Metric
Date
RE SET
Stock
Metric
Data
Saved Time


Ilford stabbing: Man killed in fight outside flats
A man was stabbed to death in a fight outside a block of east London flats in a "particularly vicious attack".
The 19-year-old was found by police responding to reports of a disturbance outside Owen Waters House, in Fullwell Avenue, Ilford, on Tuesday night.
The victim died at the scene and his next of kin have been informed.
No arrests have been made but the Met said "the possibility that the murder is gang-related is a very strong line of inquiry".
Police are establishing if the stabbing is linked to a fire at some nearby garages where a car was found burnt out.
The Met said fire crews had been called to the blaze at about 22:20 GMT while traces of blood had also been found around the vehicle.
Det Ch Insp Chris Soole described the killing as a "particularly vicious attack" and appealed for witnesses.
A Section 60 Order - giving police stop-and-search powers - was put in place for the whole of the Redbridge borough until 06:30.
There have been five murder investigations in the borough in 2019 - three of which have been as a result of fatal stabbings.
Homicides in London since 2008
Annual homicides in the Met Police area
Figures as of 20 Nov and do not include terror attacks
Source: Home Office and Metropolitan Police
So far this year, almost 130 murder investigations have been launched in the capital.
Three investigations have been carried out by British Transport Police and 124 have been investigated by the Met.
At the scene - Greg McKenzie, BBC London
A forensic tent is outside the tower block marking the spot where the teenager died.
Residents have been telling me about rising tensions in the last few weeks. The block - just off a main road in Ilford - is known as a meeting point for drug dealers and people said the issue is "rampant".
They have also described a lot of "youth disturbance and violence" in the area and expressed their fear, anger and shock.
Officers have been coming in and out of the flats and they are trying to work out whether a burnt-out car is linked to the fatal stabbing.


CVSThe OSCache CVS repository is hosted by java.net. How to log in anonymously and to checkout the current CVS HEAD is described in CVS client setup. The repository is also browsable online.  Compiling OSCacheRun build.xml with Ant 1.6.5 (or higher) under Java 1.4 or later. From the OSCache directory, type
You may need to add the Ivy jar to your $ANT_HOME/lib directory if it is not there already. |


What is surf paradise? Is it a place? A state of mind? What does surf paradise mean to you? Groundswell is all about finding that place. Whether it's checking out the latest gear, immersing yourself in the surfing lifestyle, or watching some of the sickest video this side of the pipeline, we've got you covered.

Late July saw some of the best surfing the world has ever seen. The water temperature and currents brought perfect conditions for the Maui Invitational and the field wasted no time in shredding last year's scores. When the dust settled Simon Craven won his first ever Maui title. Fresh off his win in Australia, it looks like Simon's a name we'll be hearing a lot of in the future!
Up and coming surf shop Velosurty released a their new long board last month. "Keerang!" echo's the super-hero theme of their last long board, "Bang-Pow!" Artist Kelly Crandle supplies the look and feel. This board guarantees a smooth ride and eye-catching looks. In stores next month. While you're at it, check out our new boards as well!
You may have noticed things look a little different here at Groundswell! We'll we decided it was time for a change and wanted a fresher look. Thanks to the awesome web techniques we learned from lynda.com, we were able to completely redesign the site. If you are interested in web design at all you should probably check them out as well!


awe6.interfaces.IInputKeyboard
- type
- interface
The IInputKeyboard interface should be implemented by an object wishing to be used as a virtual keyboard input device.
Instance Methods
- parameters
type
They key.
- returns
- Returns true is the key is currently down, false otherwise.
- parameters
type
The key.
- returns
- Returns true is the key was pressed in the current update, false otherwise.
- parameters
type
The key.
- returns
- Returns true is the key was released in the current update, false otherwise.
- parameters
type
The keyCode.
- returns
- Returns the key of the corresponding keyboard keyCode.
- parameters
type
The key.
- returns
- Returns the keyboard keyCode of the corresponding key.
- parameters
type
The key.
?asTime
If true then returns duration as milliseconds, else returns duration as frame updates.
?isPrevious
If true then returns the previous duration down (the time held prior to the most recent release).
- returns
- Returns the duration the key has been down.
- parameters
type
The key.
?asTime
If true then returns duration as milliseconds, else returns duration as frame updates.
?isPrevious
If true then returns the previous duration up (the time unused prior to the most recent press).
- returns
- Returns the duration the key has been up.


What is 'Black Pip'?
A black oblong in the right hand corner of a battle card.
When attacking, the number of black pips on the battle cards the attacker flips are added to the overall
What is 'Blue Pip'?
A blue oblong in the right hand corner of a battle card.
When defending, the number of blue pips on the battle cards the defender flips are added to the overall defence.
What is 'Green Pip'?
A green oblong in the right hand corner of a battle card.
When battle cards are flipped in either defence or attack, one battle card with a green pip on it may be swapped with a battle card in the player's hand.
What is 'Orange Pip'?
An orange oblong in the right hand corner of a battle card.
When attacking, the number of orange pips on the battle cards the attacker flips are added to the overall attack.
What is 'White Pip'?
An white oblong in the right hand corner of a battle card.
When attacking or defending, the first white pip flipped means the player flips two more battle cards. Additional white pips do not lead to more battle cards being flipped unless an effect explicitly states it does.


Click the link below for more details on blockchain and network
Click the link below to view the Indexer API Documentation


Admin Login
Please enter your username and password
Forgot password?
Login
© 2019 {{s.siteName}}
Powered by:
WebsiteMixer


Go back!
Tag reports
untagged
View all feature reports
View passed features
View Failed features
Feature report:
Cucumber report
Feature Name
Scenarios
Steps
Duration
Total
Passed
Failed
Total
Passed
Failed
Skipped
bdd\groups.feature
3
3
0
12
12
0
0
11 s : 980 ms
TOTALS
1
3
3
0
12
12
0
0
11 s : 980 ms


Combine my love for Pong and Po in Kungfu Panda, "Kungfu Pong" was born. Pit yourself against your friends and see who has the quickest reflex!  Muse is the platform for you to share your thoughts!
Source Code View ProjectI love deriving insights through data and wanted to create a data visualisation app. Being new to the coding scene, I had no idea how apps were faring in various countries. To answer my question, I created an android heatmap tool to understand how app preferences differ among countries by categories.
Source Code View ProjectSingaporeans like to complain, but are they happy? Understand Singapore's happiness ranking and factors that are important.
View Project


{% from "ui/partial/pagination.html" import render_pagination with context %} {% from "ui/partial/_column_operations.html" import render_column_filter, render_column_sorting with context %}


--- layout: page title: About header-img: "img/about-bg.png" ---
A programmer from the Bronx, New York based out of Palm Bay, Florida. If you would like to check out my portfolio here is the URL: https://codenameransom.github.io/Portfolio_page/


# Welcome to CyleNet Hey. Welcome to CyleNet. Type a CRL (like a URL) into the address bar above and let's do this. The default view shows Markdown files as plain text (like this), but you can toggle rendering Markdown as HTML with the button at the top right.


git config
Usage: git config –global user.name “[name]”
Usage: git config –global user.email “[email address]”
This command sets the author name and email address respectively to be used with your commits.git init
Usage: git init [repository name]
This command is used to start a new repository.git clone
Usage: git clone [url]
This command is used to obtain a repository from an existing URL.git add
Usage: git add [file]
This command adds a file to the staging area.Usage: git add *
This command adds one or more to the staging area.git commit
Usage: git commit -m “[ Type in the commit message]”
This command records or snapshots the file permanently in the version history.Usage: git commit -a
This command commits any files you’ve added with the git add command and also commits any files you’ve changed since then.git diff
Usage: git diff
This command shows the file differences which are not yet staged.Usage: git diff –staged
This command shows the differences between the files in the staging area and the latest version present.Usage: git diff [first branch] [second branch]
This command shows the differences between the two branches mentioned.git reset
Usage: git reset [file]
This command unstages the file, but it preserves the file contents.Usage: git reset [commit]
This command undoes all the commits after the specified commit and preserves the changes locally.Usage: git reset –hard [commit] This command discards all history and goes back to the specified commit.


Create a new, blank project.
Created project {{ form.controls['name'].value }} and switched to it. You are ready to go!


Retro Revival: MediEvil
Interview with Chris Berrow & Leigh Milner, Naked Gaming Pod
Part of the show Simulator Special 2
Leigh Milner and Chris Berrow review the new version of MediEvil!
Chris - First released in 1998. So it's 21 years old now actually athleticism massively improved version from the original but then I never played the original whereas you had sort of do you think.
Leigh - I think the graphics are the biggest change. I think it's much smoother. I think I can actually see what he looks like is a bit pixilated before it was wasn't it. You know how the old games looked on the PlayStation everything was chipped to bear and you kind of sometimes you look through walls and you think I shouldn't see that no. That's not so. Yeah.
Chris - The concept for this game is that one of the funniest concepts I've ever heard.  But the truth is that actually he got shot by an arrow in the eye and died. And if one just pretended that he defeated the big boss. So now that this big boss has returned and revived everybody from the dead it's like Oh right a bear actually defeat the big boss this time because it's my real chance to do that. Let's say a new play is this kind of. Yeah. It is like blessed. You know he's giving his best go. But there's sword combat and stuff. It's actually really good.


New Zealand workers need to use the toilet
by Rail And Maritime Transport Union19 November 2019
Women are taking medication to dehydrate themselves because they cannot access a toilet at work.
Today is World Toilet Day, and members of the Rail & Maritime Transport Union say they have been holding on far too long in their wait for safe and secure bathroom access.
“We should all be able to take for granted our right to go to the toilet when we need to,” says Wayne Butson, National Secretary of the RMTU.
“Unfortunately, too many employers do not provide suitable bathroom facilities for their staff.”
At a recent forum for women in the RMTU, attendees shared horror stories about how even when a toilet was provided it was not designed with women in mind.
Male urinals can be found in women's bathrooms, and in some workplaces there is no female bathroom at all.
In one railway mechanical depot the women’s wash facility is in a separate location to the changing room, forcing women to run the gauntlet in a towel from their workplace shower to the changing room.
Two women recently began employment in a South Island railway workplace that has historically been male dominated.
They discovered to their extreme discomfort they were expected to share the men’s toilet and shower facilities, and when the RMTU complained on their behalf the initial response was to offer only a “sanitary bin” for female staff.
"It is incredible that women and men have put up with this issue for so long. If employers are serious about encouraging more women to work in blue collar industries, they need to make women welcome by providing adequate toilet and wash facilities," says Karen Fletcher, RMTU health and safety organiser.
“Expecting people to just pop a squat in the bushes whilst they're working on a railway track is not okay. It's time to do something about it."
ENDS


Joshua Ward
Assignment 2
If this is checked the form will NOT submit
If this is checked the form will NOT submit


Graeco feugiat intellegam at vix
The only prerequisite is that it makes you happy. If it makes you happy then it's good. We'll take a little bit of Van Dyke Brown. It takes dark in order to show light.  Each highlight must have it's own private shadow. Put light against light - you have nothing. Put dark against dark - you have nothing. It's the contrast of light and dark that each give the other one meaning.
Happy painting, God bless. This is a fantastic little painting. Mountains are so simple, they're hard. We'll lay all these little funky little things in there.
Fluff it up a little and hypnotize it.  Everything is happy if you choose to make it that way. Work on one thing at a time. Don't get carried away - we have plenty of time.  A beautiful little sunset.


cWynn Homepage | Back to game
Help Section:
Powerups: +1000pts
You have to hit powerups with your player, shooting them destroys them
Increase the power of your bullets
Red is weakest, Green medium, Blue is most powerful
Increase the number of bullets
You start with 1, max is 3
Increase your number of lives
You start with 3, maximum is 5 lives, if you get to 0 lives the game ends
Things that hurt you:
Boss Cat
Bosses don't actually hurt you but the shoot hairballs at you
Bosses have 50hp, but get more hp as you progress
Hairball
Bosses shoot these at you; Getting hit by one will cost you a life
Hairballs have 2hp (two red bullets or one green or one blue will take care of it)
Gizmo
Ceasar
These guys will also cost you a life you they touch you
They each have 3 hp


The default is the english (en) directory - if one file in the others is missing, the eglish will be displayed instead. So don't worry about links to missing files from partial translated docs ... While the HTML syntax is valid to the renderengine, errors with missing files are impossible.