Servers > Mainframe servers > Software > Java on z/OS >

JRIO Glossary of terms

The following is a glossary of terms for the JRIO documentation.

You can click on one of the following letters to view any terms beginning with that letter.

A

abstract class: A class that defines an interface or partially implements one (see also concrete class).

access method: A software mechanism for accessing data in a file system. Access methods can support sequential access, random access, and keyed access (for example, VSAM).

alternate index: An optional index component of a cluster (see also primary index). May contain unique keys or nonunique keys. May be accessed for read-only or for read/write.

Return to start of Glossary

B- C

big-endian: A type of byte ordering in which the most significant bytes are in the lowest, or leftmost, storage locations. Java, OS/390, most mainframes, and networks use big-endian. Some minicomputers and workstations also use it. See: byte order, endian, and little-endian. Also known as network-byte-order.

byte order: The order in which numeric and character values are stored in storage. The Record Framework provides support for converting between different byte orders on a field basis. See big-endian, endian, and little-endian.

cluster: The name given to the set of related files that provide keyed access to records. A minimal cluster includes a primary index file and a data file.

concrete class: A class whose objects fully implement one or more interfaces (see also abstract class).

configuration: A collection of classes and properties that work together. This combination determines, at run time, the order in which factories are called and ultimately the kind of concrete classes used.

This permits an application to run, without modification, in different ways (for example, with files in different file systems). The configuration can be determined by a Java command-line property, the contents of a property file, or by the ordering of .jar or .zip files in the Java CLASSPATH.

Return to start of Glossary

D

directory: A logical collection of files (and sometimes, directories). Generally supports listing, adding, and removing files. Can be implemented as (or stored within) a file, but is not always. Has many characteristics in common with files, such as name, parent, and read/write permissions.

directory factory: A factory that returns a Java reference-to-an-interface that locates a concrete class object that implements a directory interface. (For example, " IDirectory dir = Directory.getInstanceOf(dirName);" returns some directory implementation object, based on the configuration at run time.)

Return to start of Glossary

E- F

endian: A term describing different ways of ordering bytes in storage to represent values. See big-endian, byte order, and little-endian. This term has been used since 1980 to describe the different ways various computer architectures store values in memory. The term comes from the book Gulliver's Travels, in which the Lilliputians fought over a law that required all soft-boiled eggs to be cracked at the little end.

factory: An object that creates (or locates) other objects. Objects are usually created with "new," which is analogous to having a static ( factory) method on the object's class object. Often such static methods are named getInstanceOf() or newInstance().
This allows users of an interface to obtain instances of objects that implement the desired interface, without knowing or specifying the concrete class of the object. This allows a run-time choice of which implementation to use, based on the configuration.

field: One or more adjacent bytes within a record. A logical division of a record into parts. A record contains one or more fields. Each field is located through a relative offset from the start of the record, where the offset is counting bytes or prior fields. A field has an underlying data type, which may or may not be converted to a Java language primitive type (see field type). Java.io supports reading and writing of Java primitive types and serialized objects as fields. You can use JRIO to support additional field types. Part of the VisualAge for Java Record Framework.

field type: The data type of a field (for example, integer, character, and so forth). Part of the VisualAge for Java Record Framework.

file: A collection of related information that is treated as a unit. This can be a named set of records stored or processed as a unit. Usually represents data stored on disk or tape (sometimes in-memory). Usually logically contained within a directory. Has many characteristics in common with directories, such as name, parent, and read/write permissions. See record file.

file factory: A factory that returns a Java reference-to-an-interface, which locates an instance of the concrete class that implements a file or stream interface. (For example, " IRecordFile file = RecordFile.getInstanceOf(fileName);" returns some directory implementation object, based on the configuration at run time.)

file system: A collection of related directories, files, and access methods that defines how data is named and accessed.

fixed length: An attribute of a record or a file (see also variable length). All of the records in a fixed-length record file are the same length. This permits the records to be stored without repeating the length attribute for each record (the length is stored once, in the file's attributes).

framework: A collection of interfaces, abstract classes, and concrete classes that work together to provide some function, usually customized by providing custom objects with methods that are called by the framework in some appropriate order.

This is different from the more traditional library usage where the application decides which methods to call and when. The VisualAge for Java Record Framework is an example of an object-oriented framework. (This is not to be confused with the generic use of the term framework, which is often used to describe almost anything that acts as a system.)

Return to start of Glossary

G- H

handle: Part of a design pattern known as handle/ rep (also known as proxy). A mechanism that provides a wrapper for a concrete class, much like a Java reference-to-an-interface. Handle classes implement the methods of an interface using wrapper methods, which typically forward the method's parameters to a concrete implementation (the rep) and then return any data returned by the rep.

One advantage of using a handle is that different subsets of the methods in an interface can be handled by different concrete classes (unlike interfaces). Another advantage is that you can easily create handles using "new," without knowing or specifying at compile-time the concrete class to be used at run time. (For example, " Directory dir = new Directory(dirName);" returns a handle object that contains a reference to some directory implementation object, based on the configuration at run time.)

Return to start of Glossary

I

index: Contains a mapping from a key to one or more records in a file. This mapping is usually persistent and, therefore, is stored in another file when the record file is closed (see cluster). Grouped indexes are updated whenever any record is updated or added. If an index in a group cannot tolerate the new or changed record (for example, if it would introduce a duplicate key in a unique key index), neither the indexes nor the data file are updated (the write or update fails).

interface: An abstract class that provides no implementation but only specifies the operations (through method signatures) required of any concrete class that implements the interface (see also handle).

An advantage of Java references-to- interfaces is that the compiler automatically generates the code to forward the calls to a concrete class.

A disadvantage is that "new" cannot be used to instantiate an interface--a concrete class must be used and, therefore, must be statically known at compile-time; this prevents dynamically choosing the class at run time (unless the concrete class is a handle).

Return to start of Glossary

J- K

key: A collection of bytes that is used to locate a corresponding record (see also key descriptor).

keyed access: The ability to locate a record in a file through a key (see also sequential access and random access). After using a key to locate the desired record, you can use sequential access to read subsequent records.

keyed access file: A file that implements keyed access. For example, you can use JRIO's KeyedAccessRecordFile object to access data in a VSAM KSDS.

key descriptor: Specifies which bytes in a record to use as a key for a particular index. The minimal description of a key includes its offset within a record and its length.

KSDS: VSAM Key-Sequenced Data Set (KSDS), a keyed access file. The KSDS supports a primary index and optional alternate indexes. It supports the use of unique keys and, optionally, nonunique keys.

Return to start of Glossary

L- M- N

little-endian: A type of byte ordering (used by IBM-compatible personal computers) in which the most significant bytes are in the higher, or rightmost, storage locations for each multi-byte value. Unlike big-endian, the number of byes in each value determines the exact ordering of the bytes. For example, the four characters "UNIX" are stored as "NUXI" on a little-endian computer.

nonunique key: A kind of index that contains keys that map to one or more records (see unique key). When you are using random access to locate a record through a nonunique key, typically the oldest record for the key is found first. Additional records, if any, may be processed using sequential access. A KeyedAccessRecordFile always has a unique key index (the primary index) and may also have zero or more nonunique key alternate indexes.

Return to start of Glossary

O- P

primary index: A unique key index for a keyed access record file (see also alternate index). This component of a cluster is always required.

proxy: See handle and rep.

Return to start of Glossary

Q- R

random access: The ability to locate a record in a file through relative seeks (see also sequential access and keyed access). Once the desired record is located, you can use sequential access to read subsequent records.

random access file: A file that implements random access (for example, JRIO's RandomAccessRecordFile).

record: Logically, a collection of application data elements related by some application-level semantic. Physically, a record can be stored and retrieved (or sent and received) as a byte array or as a Java object. See Record Framework.

record file: A file of records. Has many characteristics in common with directories, such as name, parent, and read/write permissions.

Record Framework: This is part of the VisualAge for Java, Enterprise Edition, V2.0 product. It provides support for defining a field, field type, record, and record type. It supports dynamic and static records. Dynamic records are composed at run time by a factory or constructor using the add field protocol. Static records are composed at compile time. Static records are fixed-length. Dynamic records can be fixed-length or variable-length. See the VisualAge for Java Enterprise Edition Record Framework information.

record type: An object that represents the layout of fields within a record. Part of the VisualAge for Java Record Framework.

relative record number (RRN): The integral offset to a record, relative to the start of a record file, starting with relative record number zero for the first record. Used during random access processing as the argument to the seek method. (For example, the method positionFirst() locates relative record number zero.)

rep: Part of a design pattern known as handle/ rep (also known as proxy). Short for representation, this is the concrete class that receives calls forwarded by the handle. (A Java reference-to-an-interface within a handle can point to this.)

RRN: See relative record number.

Return to start of Glossary

S

seek: Used during random access processing of a record file. The act of moving an implicit cursor to the specified relative record number, so that the next read returns the specified record in the file.

sequential access: The ability to read each record in a file in order (see also random access and keyed access). This is the access method that input and output record streams provide.
Also, you can use sequential access to read subsequent records after locating a desired record using a relative record number or a key.

stream: A flow of data that is sequentially accessed. JRIO streams process records (usually in a record file) sequentially. Examples: JRIO's non-VSAM FileInputRecordStream and FileOutputRecordStream. (See also access method, sequential access, random access file, and keyed access file).

Return to start of Glossary

T- U

typeset: A set of customized types (for example, numeric or character) representing how a language writes data to a file.

unique key: A kind of index that contains keys that map to zero or one unique record (see also nonunique key). When using random access to locate a record through a unique key, typically the record matching the key is found or, optionally, the next higher key is found.
Additional records, if any, can be processed using sequential access. KeyedAccessRecordFiles always have a unique key index (the primary index) and can also have zero or more unique key alternate indexes.

UCS: Universal Character Set, a standard encoding for a large set of characters. (It is also called Unicode.)
UCS-2, which is the most common form, uses 2 bytes per character. This is what Java uses internally. (UCS-4 uses 4 bytes per character.)

Unicode: See UCS.

UTF: UCS Transformation Format, generally a more compact encoding than UCS-2 or UCS-4. (See UCS.) UTF uses a variable number of bytes per character. UTF-8 uses 1 byte for the most common characters, 2 bytes for most nonideographic characters, and 3 bytes for ideographic ones. The UTF-8 examples assume the 1-byte character subset of UTF-8.

Return to start of Glossary

V

variable length: An attribute of a record or a file (see also fixed length). Each of the records in a variable length record file can be different lengths. Usually, this requires the length of each record to be stored in the file, at an overhead of a few bytes per record.

VSAM: S/390 Virtual Storage Access Method, an access method that provides sequential access, random access, and keyed access to record files. JRIO provides Java Native Interface (JNI) drivers that use real VSAM KSDS clusters to implement KeyedAccessRecordFiles. This enables Java applications on OS/390 to access data in VSAM KSDS clusters.

Return to start of Glossary

W- X- Y- Z

Return to start of Glossary