<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (16) -->
<title>Dump (OpenJ9 JDK 16)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: module: openj9.dtfj, package: com.ibm.dtfj.corereaders.zos.dumpreader, class: Dump">
<meta name="generator" content="javadoc/ClassWriterImpl">
<meta name="keywords" content="com.ibm.dtfj.corereaders.zos.dumpreader.Dump class">
<meta name="keywords" content="isValid()">
<meta name="keywords" content="seek()">
<meta name="keywords" content="read()">
<meta name="keywords" content="length()">
<meta name="keywords" content="getAddressSpaces()">
<meta name="keywords" content="is64bit()">
<meta name="keywords" content="getTitle()">
<meta name="keywords" content="getProductName()">
<meta name="keywords" content="getProductVersion()">
<meta name="keywords" content="getProductRelease()">
<meta name="keywords" content="getProductModification()">
<meta name="keywords" content="mvsClockToDate()">
<meta name="keywords" content="getCreationDate()">
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar.top">
<div class="skip-nav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><div style="margin-top: 9px;"><strong>OpenJ9 JDK 16</strong></div></div>
<ul id="navbar.top.firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../../../index.html">Overview</a></li>
<li><a href="../../../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/Dump.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-files/index-1.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip.navbar.top">
<!--   -->
</span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="module-label-in-type">Module</span>&nbsp;<a href="../../../../../../module-summary.html">openj9.dtfj</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">com.ibm.dtfj.corereaders.zos.dumpreader</a></div>
<h1 title="Class Dump" class="title">Class Dump</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">java.lang.Object</a>
<div class="inheritance"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">javax.imageio.stream.ImageInputStreamImpl</a>
<div class="inheritance">com.ibm.dtfj.corereaders.zos.dumpreader.Dump</div>
</div>
</div>
<section class="description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/Closeable.html" title="class or interface in java.io" class="external-link" target="_blank">Closeable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/DataInput.html" title="class or interface in java.io" class="external-link" target="_blank">DataInput</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link" target="_blank">AutoCloseable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">Dump</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></span></div>
<div class="block">This class represents an svcdump. It is the main class in the dumpreader package and
 provides low-level access to the contents of an svcdump (eg the ability to read the contents
 of an address in a given address space).
 <p>
 Implementation note: currently implemented by linking to the old svcdump.jar code (so you
 need to include svcdump.jar when using) but this dependency will eventually be removed.
 Note: zebedee dependency on svcdump.jar has been removed</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field.summary">
<h2>Field Summary</h2>
<div class="inherited-list">
<h3 id="fields.inherited.from.class.javax.imageio.stream.ImageInputStreamImpl">Fields declared in class&nbsp;javax.imageio.stream.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#bitOffset" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">bitOffset</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#byteOrder" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">byteOrder</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#flushedPos" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">flushedPos</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#streamPos" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">streamPos</a></code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor.summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><span class="member-name-link"><a href="#%3Cinit%3E(java.lang.String)">Dump</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new instance of Dump from the given filename.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><span class="member-name-link"><a href="#%3Cinit%3E(java.lang.String,com.ibm.dtfj.corereaders.zos.dumpreader.SearchListener%5B%5D)">Dump</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename,
 <a href="SearchListener.html" title="interface in com.ibm.dtfj.corereaders.zos.dumpreader">SearchListener</a>[]&nbsp;listeners)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new instance of Dump from the given filename.</div>
</div>
<div class="col-constructor-name even-row-color"><code><span class="member-name-link"><a href="#%3Cinit%3E(java.lang.String,javax.imageio.stream.ImageInputStream,boolean)">Dump</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a>&nbsp;stream,
 boolean&nbsp;createCacheFile)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new instance of Dump from the given filename.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method.summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="AddressSpace.html" title="class in com.ibm.dtfj.corereaders.zos.dumpreader">AddressSpace</a>[]</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getAddressSpaces()">getAddressSpaces</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns an array of all the address spaces in the dump.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link" target="_blank">Date</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getCreationDate()">getCreationDate</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the time when the dump was created.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProductModification()">getProductModification</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the z/OS product modification.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProductName()">getProductName</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the z/OS product name.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProductRelease()">getProductRelease</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the z/OS product release.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProductVersion()">getProductVersion</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the z/OS product version.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getTitle()">getTitle</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the title of the dump.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#is64bit()">is64bit</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns true if this is a 64-bit dump.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#isValid(java.lang.String)">isValid</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename)</code></div>
<div class="col-last even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table">
<div class="block">Returns true if the given filename is a valid svcdump.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#length()">length</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Get the length of the dump file</div>
</div>
<div class="col-first even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code>static <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link" target="_blank">Date</a></code></div>
<div class="col-second even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#mvsClockToDate(long)">mvsClockToDate</a></span>&#8203;(long&nbsp;clock)</code></div>
<div class="col-last even-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table">
<div class="block">Convert an MVS style clock value to a Date object.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#read()">read</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Reads an unsigned byte from the file</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>int</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#read(byte%5B%5D)">read</a></span>&#8203;(byte[]&nbsp;buf)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Read from the dump file into the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#read(byte%5B%5D,int,int)">read</a></span>&#8203;(byte[]&nbsp;buf,
 int&nbsp;off,
 int&nbsp;len)</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Read from the dump file into the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>void</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#seek(long)">seek</a></span>&#8203;(long&nbsp;offset)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Seek to the given offset in the dump file.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.javax.imageio.stream.ImageInputStreamImpl">Methods declared in class&nbsp;javax.imageio.stream.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#checkClosed()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">checkClosed</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#close()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">close</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#finalize()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#flush()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">flush</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#flushBefore(long)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">flushBefore</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#getBitOffset()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">getBitOffset</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#getByteOrder()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">getByteOrder</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#getFlushedPosition()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">getFlushedPosition</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#getStreamPosition()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">getStreamPosition</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#isCached()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">isCached</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#isCachedFile()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">isCachedFile</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#isCachedMemory()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">isCachedMemory</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#mark()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">mark</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readBit()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readBit</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readBits(int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readBits</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readBoolean()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readBoolean</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readByte()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readByte</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readBytes(javax.imageio.stream.IIOByteBuffer,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readBytes</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readChar()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readChar</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readDouble()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readDouble</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFloat()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFloat</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(byte%5B%5D)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(byte%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(char%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(double%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(float%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(int%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(long%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readFully(short%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readFully</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readInt()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readInt</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readLine()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readLine</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readLong()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readLong</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readShort()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readShort</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readUnsignedByte()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readUnsignedByte</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readUnsignedInt()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readUnsignedInt</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readUnsignedShort()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readUnsignedShort</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#readUTF()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">readUTF</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#reset()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">reset</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#setBitOffset(int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">setBitOffset</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#setByteOrder(java.nio.ByteOrder)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">setByteOrder</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#skipBytes(int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">skipBytes</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#skipBytes(long)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">skipBytes</a></code></div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.java.lang.Object">Methods declared in class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link" target="_blank">clone</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link" target="_blank">equals</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link" target="_blank">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link" target="_blank">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link" target="_blank">notify</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link" target="_blank">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link" target="_blank">toString</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link" target="_blank">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link" target="_blank">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link" target="_blank">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor.detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String)">
<h3>Dump</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">Dump</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename)</span>
     throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></span></div>
<div class="block">Creates a new instance of Dump from the given filename. The filename must represent
 either an absolute or relative pathname of the dump file, or if running on z/os it can
 be an MVS dataset name (eg DGRIFF.MYDUMP).</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>filename</code> - the name of the dump to open</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,javax.imageio.stream.ImageInputStream,boolean)">
<h3>Dump</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">Dump</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a>&nbsp;stream,
 boolean&nbsp;createCacheFile)</span>
     throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></span></div>
<div class="block">Creates a new instance of Dump from the given filename. The filename must represent
 either an absolute or relative pathname of the dump file, or if running on z/os it can
 be an MVS dataset name (eg DGRIFF.MYDUMP).
 Alternatively an ImageInputStream can be provided if the file is already open.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>filename</code> - the name of the dump to open, also used to open the cache file</dd>
<dd><code>stream</code> - an ImageInputStream for the dump or null - used in preference to opening the file</dd>
<dd><code>createCacheFile</code> - Create a cache file based on the filename</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(java.lang.String,com.ibm.dtfj.corereaders.zos.dumpreader.SearchListener[])">
<h3>Dump</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">Dump</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename,
 <a href="SearchListener.html" title="interface in com.ibm.dtfj.corereaders.zos.dumpreader">SearchListener</a>[]&nbsp;listeners)</span>
     throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></span></div>
<div class="block">Creates a new instance of Dump from the given filename. The filename must represent
 either an absolute or relative pathname of the dump file, or if running on z/os it can
 be an MVS dataset name.
 <p>
 This constructor also supplies an array of <a href="SearchListener.html" title="interface in com.ibm.dtfj.corereaders.zos.dumpreader"><code>SearchListener</code></a>s
 to inform the caller of matches found whilst scanning the dump. Note that this will
 force a scan of the dump which is otherwise normally only done the first time this dump
 is opened. (XXX can probably avoid this by cacheing earlier search results).</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>filename</code> - the name of the dump to open</dd>
<dd><code>listeners</code> - the array of <a href="SearchListener.html" title="interface in com.ibm.dtfj.corereaders.zos.dumpreader"><code>SearchListener</code></a>s to be notified of interesting matches</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link" target="_blank">FileNotFoundException</a></code></dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method.detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="isValid(java.lang.String)">
<h3>isValid</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isValid</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a>&nbsp;filename)</span></div>
<div class="block">Returns true if the given filename is a valid svcdump.</div>
</section>
</li>
<li>
<section class="detail" id="seek(long)">
<h3>seek</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">seek</span>&#8203;<span class="parameters">(long&nbsp;offset)</span>
          throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></span></div>
<div class="block">Seek to the given offset in the dump file. This also handles MVS datasets in an
 efficient way (simply using fseek is too slow because the seek appears to read the
 file from the beginning every time!).</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html#seek(long)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">seek</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#seek(long)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">seek</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - the offset to seek to</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></code> - if any other I/O error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="read()">
<h3>read</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">read</span>()
         throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></span></div>
<div class="block">Reads an unsigned byte from the file</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html#read()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#read()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></code></dd>
<dt>Returns:</dt>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="read(byte[],int,int)">
<h3>read</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">read</span>&#8203;<span class="parameters">(byte[]&nbsp;buf,
 int&nbsp;off,
 int&nbsp;len)</span>
         throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></span></div>
<div class="block">Read from the dump file into the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html#read(byte%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#read(byte%5B%5D,int,int)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></code></dd>
<dt>Parameters:</dt>
<dd><code>buf</code> - the buffer to read into</dd>
<dd><code>off</code> - the offset into the buffer to start at</dd>
<dd><code>len</code> - the maximum number of bytes to read</dd>
<dt>Returns:</dt>
<dd>the number of bytes actually read, or <code>-1</code>
 to indicate EOF.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></code> - if an I/O error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="read(byte[])">
<h3>read</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">read</span>&#8203;<span class="parameters">(byte[]&nbsp;buf)</span>
         throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></span></div>
<div class="block">Read from the dump file into the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html#read(byte%5B%5D)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#read(byte%5B%5D)" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">read</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></code></dd>
<dt>Parameters:</dt>
<dd><code>buf</code> - the buffer to read into</dd>
<dt>Returns:</dt>
<dd>the number of bytes actually read, or <code>-1</code>
 to indicate EOF.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link" target="_blank">IOException</a></code> - if an I/O error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="length()">
<h3>length</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">length</span>()</div>
<div class="block">Get the length of the dump file</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html#length()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">length</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStream.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStream</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html#length()" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">length</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.desktop/javax/imageio/stream/ImageInputStreamImpl.html" title="class or interface in javax.imageio.stream" class="external-link" target="_blank">ImageInputStreamImpl</a></code></dd>
<dt>Returns:</dt>
<dd>-1L to indicate unknown length.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getAddressSpaces()">
<h3>getAddressSpaces</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="AddressSpace.html" title="class in com.ibm.dtfj.corereaders.zos.dumpreader">AddressSpace</a>[]</span>&nbsp;<span class="element-name">getAddressSpaces</span>()</div>
<div class="block">Returns an array of all the address spaces in the dump.</div>
</section>
</li>
<li>
<section class="detail" id="is64bit()">
<h3>is64bit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">is64bit</span>()</div>
<div class="block">Returns true if this is a 64-bit dump. Always returns false at the moment 'cos I
 haven't yet got my paws on a 64-bit dump.</div>
</section>
</li>
<li>
<section class="detail" id="getTitle()">
<h3>getTitle</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getTitle</span>()</div>
<div class="block">Returns the title of the dump.</div>
</section>
</li>
<li>
<section class="detail" id="getProductName()">
<h3>getProductName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getProductName</span>()</div>
<div class="block">Returns the z/OS product name.</div>
</section>
</li>
<li>
<section class="detail" id="getProductVersion()">
<h3>getProductVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getProductVersion</span>()</div>
<div class="block">Returns the z/OS product version.</div>
</section>
</li>
<li>
<section class="detail" id="getProductRelease()">
<h3>getProductRelease</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getProductRelease</span>()</div>
<div class="block">Returns the z/OS product release.</div>
</section>
</li>
<li>
<section class="detail" id="getProductModification()">
<h3>getProductModification</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getProductModification</span>()</div>
<div class="block">Returns the z/OS product modification.</div>
</section>
</li>
<li>
<section class="detail" id="mvsClockToDate(long)">
<h3>mvsClockToDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link" target="_blank">Date</a></span>&nbsp;<span class="element-name">mvsClockToDate</span>&#8203;<span class="parameters">(long&nbsp;clock)</span></div>
<div class="block">Convert an MVS style clock value to a Date object.</div>
</section>
</li>
<li>
<section class="detail" id="getCreationDate()">
<h3>getCreationDate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link" target="_blank">Date</a></span>&nbsp;<span class="element-name">getCreationDate</span>()</div>
<div class="block">Returns the time when the dump was created.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small><a href="https://www.eclipse.org/openj9/" target="_blank">Eclipse OpenJ9 website.</a><br> To raise a bug report or suggest an improvement create an <a href="https://github.com/eclipse-openj9/openj9/issues" target="_blank">Eclipse Openj9 issue.</a><br> Copyright &copy; 1998, 2021, IBM Corp. and others.</small></p>
</footer>
</div>
</div>
</body>
</html>
