<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_252) on Fri Jul 16 09:39:03 UTC 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>IdentityMapAccessor (EclipseLink 3.0.2, API Reference)</title>
<meta name="date" content="2021-07-16">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="IdentityMapAccessor (EclipseLink 3.0.2, API Reference)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":6,"i1":6,"i2":6,"i3":6,"i4":6,"i5":6,"i6":6,"i7":6,"i8":6,"i9":6,"i10":6,"i11":6,"i12":6,"i13":6,"i14":6,"i15":6,"i16":6,"i17":6,"i18":6,"i19":6,"i20":6,"i21":6,"i22":6,"i23":6,"i24":6,"i25":6,"i26":6,"i27":6,"i28":6,"i29":6,"i30":6,"i31":6,"i32":6,"i33":6,"i34":6,"i35":6,"i36":6,"i37":6,"i38":6,"i39":6,"i40":6,"i41":6,"i42":6,"i43":6,"i44":6,"i45":6,"i46":6,"i47":6,"i48":6,"i49":6,"i50":6,"i51":6,"i52":6,"i53":6};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],4:["t3","Abstract Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">EclipseLink 3.0.2, API Reference</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/eclipse/persistence/sessions/ExternalTransactionController.html" title="interface in org.eclipse.persistence.sessions"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/eclipse/persistence/sessions/JNDIConnector.html" title="class in org.eclipse.persistence.sessions"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/persistence/sessions/IdentityMapAccessor.html" target="_top">Frames</a></li>
<li><a href="IdentityMapAccessor.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.eclipse.persistence.sessions</div>
<h2 title="Interface IdentityMapAccessor" class="title">Interface IdentityMapAccessor</h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public interface <span class="typeNameLabel">IdentityMapAccessor</span></pre>
<div class="block">PUBLIC:
 IdentityMapAccessor provides the public interface into all functionality associated with
 EclipseLink's cache. An appropriate IdentityMapAccessor can be obtained from a session
 with its getIdentityMapAccessor() method.
 Methods that used to be called on the Session to access identity maps can now be called
 through the IdentityMapAccessor.
 <p>
 For instance, to initialize identity maps the code used to be:
 <code>
 session.initializeIdentityIdentityMaps()<br></code>
 With this class, the code now is:<code><br>
 session.getIdentityMapAccessor().initializeIdentityMaps()
 </code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../org/eclipse/persistence/sessions/Session.html" title="interface in org.eclipse.persistence.sessions"><code>Session</code></a></dd>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t3" class="tableTab"><span><a href="javascript:show(4);">Abstract Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#clearQueryCache--">clearQueryCache</a></span>()</code>
<div class="block">ADVANCED:
 Clear all the query caches</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#clearQueryCache-org.eclipse.persistence.queries.ReadQuery-">clearQueryCache</a></span>(<a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a>&nbsp;query)</code>
<div class="block">ADVANCED:
 Clear the query class associated with the passed-in read query.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#clearQueryCache-java.lang.String-">clearQueryCache</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sessionQueryName)</code>
<div class="block">ADVANCED:
 Clear the query cache associated with the named query on the session.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#clearQueryCache-java.lang.String-java.lang.Class-">clearQueryCache</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;descriptorQueryName,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;queryClass)</code>
<div class="block">ADVANCED:
 Clear the query cache associated with the named query on the descriptor for the given class.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#containsObjectInIdentityMap-java.lang.Object-">containsObjectInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</code>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same primary
 key and Class type of the given domainObject.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#containsObjectInIdentityMap-java.lang.Object-java.lang.Class-">containsObjectInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same
 primary key and Class type as those specified.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#containsObjectInIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-">containsObjectInIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same primary key
 of the specified row (i.e.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-">getAllFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                     <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                     <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-boolean-">getAllFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                     <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                     <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy,
                     boolean&nbsp;shouldReturnInvalidatedObjects)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-">getAllFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                     <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                     int&nbsp;valueHolderPolicy)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-boolean-">getAllFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                     <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                     int&nbsp;valueHolderPolicy,
                     boolean&nbsp;shouldReturnInvalidatedObjects)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-">getFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                  <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-">getFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                  <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                  <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-">getFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                  <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                  int&nbsp;valueHolderPolicy)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-java.lang.Object-">getFromIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</code>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 and Class type of the given domainObject.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-java.lang.Object-java.lang.Class-">getFromIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 and Class type as those specified.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-java.lang.Object-java.lang.Class-boolean-">getFromIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                  boolean&nbsp;shouldReturnInvalidatedObjects)</code>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key and Class type
 as specified.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-">getFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 of the specified row (i.e.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getFromIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-boolean-">getFromIdentityMap</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                  boolean&nbsp;shouldReturnInvalidatedObjects)</code>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key of the specified
 row and Class type.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>long</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getRemainingValidTime-java.lang.Object-">getRemainingValidTime</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</code>
<div class="block">ADVANCED:
 Returns the remaining life of the given Object.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getWriteLockValue-java.lang.Object-">getWriteLockValue</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</code>
<div class="block">ADVANCED:
 Extracts and returns the write lock value from the identity map through the given Object.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#getWriteLockValue-java.lang.Object-java.lang.Class-">getWriteLockValue</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Extracts the write lock value from the identity map through the passed in primaryKey and Class type.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#initializeAllIdentityMaps--">initializeAllIdentityMaps</a></span>()</code>
<div class="block">PUBLIC:
 Resets the entire Object cache.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#initializeIdentityMap-java.lang.Class-">initializeIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">PUBLIC:
 Resets the identity map for only the instances of the given Class type.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#initializeIdentityMaps--">initializeIdentityMaps</a></span>()</code>
<div class="block">PUBLIC:
 Resets the entire local Object cache.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateAll--">invalidateAll</a></span>()</code>
<div class="block">ADVANCED:
 Sets all of the Objects for all classes to be invalid in the cache.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateClass-java.lang.Class-">invalidateClass</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Sets all of the Objects of the specified Class type to be invalid in the cache.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateClass-java.lang.Class-boolean-">invalidateClass</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
               boolean&nbsp;recurse)</code>
<div class="block">ADVANCED:
 Sets all of the Objects of the specified Class type to be invalid in the cache.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-java.lang.Object-">invalidateObject</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</code>
<div class="block">ADVANCED:
 Sets an Object to be invalid in the cache.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-java.lang.Object-boolean-">invalidateObject</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object,
                boolean&nbsp;invalidateCluster)</code>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-java.lang.Object-java.lang.Class-">invalidateObject</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Sets an Object with the specified primary key and Class type to be invalid in
 the cache.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-java.lang.Object-java.lang.Class-boolean-">invalidateObject</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                boolean&nbsp;invalidateCluster)</code>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-org.eclipse.persistence.sessions.Record-java.lang.Class-">invalidateObject</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Sets an Object with the specified primary key of the passed in Row and Class type to
 be invalid in the cache.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObject-org.eclipse.persistence.sessions.Record-java.lang.Class-boolean-">invalidateObject</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                boolean&nbsp;invalidateCluster)</code>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObjects-java.util.Collection-">invalidateObjects</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&nbsp;collection)</code>
<div class="block">ADVANCED:
 Sets all of the Objects in the given collection to be invalid in the TopLink identity maps.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObjects-java.util.Collection-boolean-">invalidateObjects</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&nbsp;collection,
                 boolean&nbsp;invalidateCluster)</code>
<div class="block">ADVANCED:
 Set all of the objects in the given collection to be invalid in the cache.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObjects-org.eclipse.persistence.expressions.Expression-">invalidateObjects</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria)</code>
<div class="block">ADVANCED:
 Sets all of the Objects matching the given Expression to be invalid in the cache.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateObjects-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-boolean-">invalidateObjects</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                 <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                 boolean&nbsp;shouldInvalidateOnException)</code>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and invalidates matching Objects.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#invalidateQueryCache-java.lang.Class-">invalidateQueryCache</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;classThatChanged)</code>
<div class="block">ADVANCED:
 Invalidate/remove any results for any query for the class from the query cache.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#isValid-java.lang.Object-">isValid</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</code>
<div class="block">ADVANCED:
 Returns true if an Object with the same primary key and Class type of the
 the given Object is valid in the cache.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#isValid-java.lang.Object-java.lang.Class-">isValid</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns true if the Object described by the given primary key and Class type is valid
 in the cache.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#isValid-org.eclipse.persistence.sessions.Record-java.lang.Class-">isValid</a></span>(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Returns true if this Object with the given primary key of the Row and Class type
 given is valid in the cache.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#printIdentityMap-java.lang.Class-">printIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">PUBLIC:
 Used to print all the Objects in the identity map of the given Class type.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#printIdentityMapLocks--">printIdentityMapLocks</a></span>()</code>
<div class="block">PUBLIC:
 Used to print all the locks in every identity map in this session.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#printIdentityMaps--">printIdentityMaps</a></span>()</code>
<div class="block">PUBLIC:
 Used to print all the Objects in every identity map in this session.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#putInIdentityMap-java.lang.Object-">putInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</code>
<div class="block">ADVANCED:
 Registers the given Object with the identity map.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#putInIdentityMap-java.lang.Object-java.lang.Object-">putInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key)</code>
<div class="block">ADVANCED:
 Registers the Object and given key with the identity map.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#putInIdentityMap-java.lang.Object-java.lang.Object-java.lang.Object-">putInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</code>
<div class="block">ADVANCED:
 Registers the Object and given key with the identity map.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#putInIdentityMap-java.lang.Object-java.lang.Object-java.lang.Object-long-">putInIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue,
                long&nbsp;readTime)</code>
<div class="block">ADVANCED:
 Registers the given Object with the identity map.</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#removeFromIdentityMap-java.lang.Object-">removeFromIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</code>
<div class="block">ADVANCED:
 Removes the Object from the Object cache.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#removeFromIdentityMap-java.lang.Object-java.lang.Class-">removeFromIdentityMap</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</code>
<div class="block">ADVANCED:
 Removes the Object with given primary key and Class from the Object cache.</div>
</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#updateWriteLockValue-java.lang.Object-java.lang.Class-java.lang.Object-">updateWriteLockValue</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</code>
<div class="block">ADVANCED:
 Updates the write lock value in the cache for the Object with same primary key as the given Object.</div>
</td>
</tr>
<tr id="i52" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#updateWriteLockValue-java.lang.Object-java.lang.Object-">updateWriteLockValue</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</code>
<div class="block">ADVANCED:
 Updates the write lock value in the identity map for cache key of the primary key
 the given Object.</div>
</td>
</tr>
<tr id="i53" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/sessions/IdentityMapAccessor.html#validateCache--">validateCache</a></span>()</code>
<div class="block">ADVANCED:
 This can be used to help debugging an Object identity problem.</div>
</td>
</tr>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="clearQueryCache--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clearQueryCache</h4>
<pre>void&nbsp;clearQueryCache()</pre>
<div class="block">ADVANCED:
 Clear all the query caches</div>
</li>
</ul>
<a name="clearQueryCache-org.eclipse.persistence.queries.ReadQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clearQueryCache</h4>
<pre>void&nbsp;clearQueryCache(<a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a>&nbsp;query)</pre>
<div class="block">ADVANCED:
 Clear the query class associated with the passed-in read query.</div>
</li>
</ul>
<a name="clearQueryCache-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clearQueryCache</h4>
<pre>void&nbsp;clearQueryCache(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sessionQueryName)</pre>
<div class="block">ADVANCED:
 Clear the query cache associated with the named query on the session.</div>
</li>
</ul>
<a name="clearQueryCache-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clearQueryCache</h4>
<pre>void&nbsp;clearQueryCache(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;descriptorQueryName,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;queryClass)</pre>
<div class="block">ADVANCED:
 Clear the query cache associated with the named query on the descriptor for the given class.</div>
</li>
</ul>
<a name="invalidateQueryCache-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateQueryCache</h4>
<pre>void&nbsp;invalidateQueryCache(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;classThatChanged)</pre>
<div class="block">ADVANCED:
 Invalidate/remove any results for any query for the class from the query cache.
 This is used to invalidate the query cache on any change.</div>
</li>
</ul>
<a name="containsObjectInIdentityMap-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>containsObjectInIdentityMap</h4>
<pre>boolean&nbsp;containsObjectInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</pre>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same primary
 key and Class type of the given domainObject.</div>
</li>
</ul>
<a name="containsObjectInIdentityMap-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>containsObjectInIdentityMap</h4>
<pre>boolean&nbsp;containsObjectInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same
 primary key and Class type as those specified.</div>
</li>
</ul>
<a name="containsObjectInIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>containsObjectInIdentityMap</h4>
<pre>boolean&nbsp;containsObjectInIdentityMap(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns true if the identity map contains an Object with the same primary key
 of the specified row (i.e. the database record) and Class type.</div>
</li>
</ul>
<a name="getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getAllFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                             <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                             <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy,
                             boolean&nbsp;shouldReturnInvalidatedObjects)
                      throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.
 If the expression is too complex an exception will be thrown.
 Only returns Objects that are invalid from the map if specified with the
 boolean shouldReturnInvalidatedObjects.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression selecting the Objects to be returned</dd>
<dd><code>theClass</code> - Class to be considered</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see
 <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dd><code>shouldReturnInvalidatedObjects</code> - boolean - true if only invalid Objects should be returned</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Vector of Objects</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getAllFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                             <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                             int&nbsp;valueHolderPolicy,
                             boolean&nbsp;shouldReturnInvalidatedObjects)
                      throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.
 If the expression is too complex an exception will be thrown.
 Only returns Objects that are invalid from the map if specified with the
 boolean shouldReturnInvalidatedObjects.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression selecting the Objects to be returned</dd>
<dd><code>theClass</code> - Class to be considered</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see
 <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dd><code>shouldReturnInvalidatedObjects</code> - boolean - true if only invalid Objects should be returned</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Vector of Objects</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getAllFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                             <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                             <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy)
                      throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.
 If the expression is too complex an exception will be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression selecting the Objects to be returned</dd>
<dd><code>theClass</code> - Class to be considered</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see
 <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Vector of Objects with type theClass and matching the selectionCriteria</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAllFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getAllFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                             <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                             int&nbsp;valueHolderPolicy)
                      throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and returns matching Objects.
 If the expression is too complex an exception will be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression selecting the Objects to be returned</dd>
<dd><code>theClass</code> - Class to be considered</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see
 <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Vector of Objects with type theClass and matching the selectionCriteria</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</pre>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 and Class type of the given domainObject.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null.</dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 and Class type as those specified.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null.</dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key
 of the specified row (i.e. the database record) and Class type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>rowContainingPrimaryKey</code> - Record</dd>
<dd><code>theClass</code> - Class</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null.</dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-java.lang.Object-java.lang.Class-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          boolean&nbsp;shouldReturnInvalidatedObjects)</pre>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key and Class type
 as specified. May return null and will only return an Object that is invalidated
 if specified with the boolean shouldReturnInvalidatedObjects.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null.</dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-org.eclipse.persistence.sessions.Record-java.lang.Class-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          boolean&nbsp;shouldReturnInvalidatedObjects)</pre>
<div class="block">ADVANCED:
 Returns the Object from the identity map with the same primary key of the specified
 row and Class type. May return null and will only Only return an Object that is
 invalidated if specified with the boolean shouldReturnInvalidatedObjects.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>rowContainingPrimaryKey</code> - Record</dd>
<dd><code>theClass</code> - Class</dd>
<dd><code>shouldReturnInvalidatedObjects</code> - boolean</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null.</dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow)
                   throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.
 If the Object is not found with the passed in Class type, Row and selectionCriteria,
 null is returned. If the expression is too complex an exception will be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression</dd>
<dd><code>theClass</code> - Class</dd>
<dd><code>translationRow</code> - Record</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                          <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries">InMemoryQueryIndirectionPolicy</a>&nbsp;valueHolderPolicy)
                   throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.
 If the Object is not found with the passed in Class type, Row and selectionCriteria,
 null is returned. This method allows for control of un-instantiated indirection access
 with valueHolderPolicy. If the expression is too complex an exception will be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression</dd>
<dd><code>theClass</code> - Class</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getFromIdentityMap-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getFromIdentityMap(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                          int&nbsp;valueHolderPolicy)
                   throws <a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></pre>
<div class="block">ADVANCED:
 Queries the cache in-memory and returns an Object from this identity map.
 If the Object is not found with the passed in Class type, Row and selectionCriteria,
 null is returned. This method allows for control of un-instantiated indirection access
 with valueHolderPolicy. If the expression is too complex an exception will be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression</dd>
<dd><code>theClass</code> - Class</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>valueHolderPolicy</code> - see <a href="../../../../org/eclipse/persistence/queries/InMemoryQueryIndirectionPolicy.html" title="class in org.eclipse.persistence.queries"><code>InMemoryQueryIndirectionPolicy</code></a></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object from identity map, may be null</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/QueryException.html" title="class in org.eclipse.persistence.exceptions">QueryException</a></code></dd>
</dl>
</li>
</ul>
<a name="getRemainingValidTime-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRemainingValidTime</h4>
<pre>long&nbsp;getRemainingValidTime(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</pre>
<div class="block">ADVANCED:
 Returns the remaining life of the given Object.  This method is associated with use of
 cache invalidation feature and returns the difference between the next expiry
 time of the Object and its read time.  The method will return 0 for invalidated Objects.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>object</code> - Object under consideration</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>long time in milliseconds</dd>
</dl>
</li>
</ul>
<a name="getWriteLockValue-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getWriteLockValue</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getWriteLockValue(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</pre>
<div class="block">ADVANCED:
 Extracts and returns the write lock value from the identity map through the given Object.
 Write lock values are used when optimistic locking is stored in the cache instead of the object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object for versioning</dd>
</dl>
</li>
</ul>
<a name="getWriteLockValue-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getWriteLockValue</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;getWriteLockValue(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Extracts the write lock value from the identity map through the passed in primaryKey and Class type.
 Write lock values are used when optimistic locking is stored in the cache instead of the object.</div>
</li>
</ul>
<a name="initializeAllIdentityMaps--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeAllIdentityMaps</h4>
<pre>void&nbsp;initializeAllIdentityMaps()</pre>
<div class="block">PUBLIC:
 Resets the entire Object cache.
 <p> NOTE: Be careful using this method. This method blows away both this session's and its parent's caches.
 This includes the server cache or any other cache. This throws away any Objects that have been read in.
 Extreme caution should be used before doing this because Object identity will no longer
 be maintained for any Objects currently read in.  This should only be called
 if the application knows that it no longer has references to Objects held in the cache.</div>
</li>
</ul>
<a name="initializeIdentityMap-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeIdentityMap</h4>
<pre>void&nbsp;initializeIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">PUBLIC:
 Resets the identity map for only the instances of the given Class type.
 For inheritance the user must make sure that they only use the root class.
 <p> NOTE: Caution must be used in doing this to ensure that the Objects within the identity map
 are not referenced from other Objects of other classes or from the application.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>theClass</code> - Class</dd>
</dl>
</li>
</ul>
<a name="initializeIdentityMaps--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeIdentityMaps</h4>
<pre>void&nbsp;initializeIdentityMaps()</pre>
<div class="block">PUBLIC:
 Resets the entire local Object cache.
 <p> NOTE: This throws away any Objects that have been read in.
 Extreme caution should be used before doing this because Object identity will no longer
 be maintained for any Objects currently read in.  This should only be called
 if the application knows that it no longer has references to Objects held in the cache.</div>
</li>
</ul>
<a name="invalidateObject-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</pre>
<div class="block">ADVANCED:
 Sets an Object to be invalid in the cache.
 If this Object does not exist in the cache, this method will return
 without any action.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>object</code> - Object</dd>
</dl>
</li>
</ul>
<a name="invalidateObject-java.lang.Object-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object,
                      boolean&nbsp;invalidateCluster)</pre>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>invalidateCluster</code> - if true the invalidation will be broadcast to each server in the cluster.</dd>
</dl>
</li>
</ul>
<a name="invalidateObject-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Sets an Object with the specified primary key and Class type to be invalid in
 the cache. If the Object does not exist in the cache,
 this method will return without any action.</div>
</li>
</ul>
<a name="invalidateObject-java.lang.Object-java.lang.Class-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                      boolean&nbsp;invalidateCluster)</pre>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>invalidateCluster</code> - if true the invalidation will be broadcast to each server in the cluster.</dd>
</dl>
</li>
</ul>
<a name="invalidateObject-org.eclipse.persistence.sessions.Record-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Sets an Object with the specified primary key of the passed in Row and Class type to
 be invalid in the cache. If the Object does not exist in the cache,
 this method will return without any action.</div>
</li>
</ul>
<a name="invalidateObject-org.eclipse.persistence.sessions.Record-java.lang.Class-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObject</h4>
<pre>void&nbsp;invalidateObject(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                      boolean&nbsp;invalidateCluster)</pre>
<div class="block">ADVANCED:
 Set an object to be invalid in the cache.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>invalidateCluster</code> - if true the invalidation will be broadcast to each server in the cluster.</dd>
</dl>
</li>
</ul>
<a name="invalidateObjects-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObjects</h4>
<pre>void&nbsp;invalidateObjects(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&nbsp;collection)</pre>
<div class="block">ADVANCED:
 Sets all of the Objects in the given collection to be invalid in the TopLink identity maps.
 This method will take no action for any Objects in the collection that do not exist in the cache.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>collection</code> - objects to be invalidated</dd>
</dl>
</li>
</ul>
<a name="invalidateObjects-java.util.Collection-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObjects</h4>
<pre>void&nbsp;invalidateObjects(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&nbsp;collection,
                       boolean&nbsp;invalidateCluster)</pre>
<div class="block">ADVANCED:
 Set all of the objects in the given collection to be invalid in the cache.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>invalidateCluster</code> - if true the invalidation will be broadcast to each server in the cluster.</dd>
</dl>
</li>
</ul>
<a name="invalidateObjects-org.eclipse.persistence.expressions.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObjects</h4>
<pre>void&nbsp;invalidateObjects(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria)</pre>
<div class="block">ADVANCED:
 Sets all of the Objects matching the given Expression to be invalid in the cache.
 <p>
 <b>Example</b> - Invalidating Employee Objects with non-null first names:
 <p>
 <code>
  ExpressionBuilder eb = new ExpressionBuilder(Employee.class);    <br>
  Expression exp = eb.get("firstName").notNull();                  <br>
  session.getIdentityMapAccessor().invalidateObjects(exp);         <br>
 </code></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression</dd>
</dl>
</li>
</ul>
<a name="invalidateObjects-org.eclipse.persistence.expressions.Expression-java.lang.Class-org.eclipse.persistence.sessions.Record-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateObjects</h4>
<pre>void&nbsp;invalidateObjects(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;selectionCriteria,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                       <a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;translationRow,
                       boolean&nbsp;shouldInvalidateOnException)</pre>
<div class="block">ADVANCED:
 Queries the cache in-memory with the passed in criteria and invalidates matching Objects.
 If the expression is too complex either all or none object of theClass invalidated (depending on shouldInvalidateOnException value).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selectionCriteria</code> - Expression selecting the Objects to be returned</dd>
<dd><code>theClass</code> - Class to be considered</dd>
<dd><code>translationRow</code> - Record</dd>
<dd><code>shouldInvalidateOnException</code> - boolean indicates weather to invalidate the object if conform threw exception.</dd>
</dl>
</li>
</ul>
<a name="invalidateAll--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateAll</h4>
<pre>void&nbsp;invalidateAll()</pre>
<div class="block">ADVANCED:
 Sets all of the Objects for all classes to be invalid in the cache.
 It will recurse on inheritance.</div>
</li>
</ul>
<a name="invalidateClass-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateClass</h4>
<pre>void&nbsp;invalidateClass(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Sets all of the Objects of the specified Class type to be invalid in the cache.
 Will set the recurse on inheritance to true.</div>
</li>
</ul>
<a name="invalidateClass-java.lang.Class-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>invalidateClass</h4>
<pre>void&nbsp;invalidateClass(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                     boolean&nbsp;recurse)</pre>
<div class="block">ADVANCED:
 Sets all of the Objects of the specified Class type to be invalid in the cache.
 User can set the recurse flag to false if they do not want to invalidate
 all the same Class types within an inheritance tree.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>theClass</code> - Class</dd>
<dd><code>recurse</code> - boolean</dd>
</dl>
</li>
</ul>
<a name="isValid-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isValid</h4>
<pre>boolean&nbsp;isValid(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;object)</pre>
<div class="block">ADVANCED:
 Returns true if an Object with the same primary key and Class type of the
 the given Object is valid in the cache.</div>
</li>
</ul>
<a name="isValid-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isValid</h4>
<pre>boolean&nbsp;isValid(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns true if the Object described by the given primary key and Class type is valid
 in the cache.</div>
</li>
</ul>
<a name="isValid-org.eclipse.persistence.sessions.Record-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isValid</h4>
<pre>boolean&nbsp;isValid(<a href="../../../../org/eclipse/persistence/sessions/Record.html" title="interface in org.eclipse.persistence.sessions">Record</a>&nbsp;rowContainingPrimaryKey,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Returns true if this Object with the given primary key of the Row and Class type
 given is valid in the cache.</div>
</li>
</ul>
<a name="printIdentityMap-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>printIdentityMap</h4>
<pre>void&nbsp;printIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">PUBLIC:
 Used to print all the Objects in the identity map of the given Class type.
 The output of this method will be logged to this session's SessionLog at SEVERE level.</div>
</li>
</ul>
<a name="printIdentityMaps--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>printIdentityMaps</h4>
<pre>void&nbsp;printIdentityMaps()</pre>
<div class="block">PUBLIC:
 Used to print all the Objects in every identity map in this session.
 The output of this method will be logged to this session's SessionLog at SEVERE level.</div>
</li>
</ul>
<a name="printIdentityMapLocks--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>printIdentityMapLocks</h4>
<pre>void&nbsp;printIdentityMapLocks()</pre>
<div class="block">PUBLIC:
 Used to print all the locks in every identity map in this session.
 The output of this method will be logged to this session's SessionLog at FINEST level.</div>
</li>
</ul>
<a name="putInIdentityMap-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>putInIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;putInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</pre>
<div class="block">ADVANCED:
 Registers the given Object with the identity map.
 The Object must always be registered with its version number if optimistic locking is used.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object</dd>
</dl>
</li>
</ul>
<a name="putInIdentityMap-java.lang.Object-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>putInIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;putInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key)</pre>
<div class="block">ADVANCED:
 Registers the Object and given key with the identity map.
 The Object must always be registered with its version number if optimistic locking is used.</div>
</li>
</ul>
<a name="putInIdentityMap-java.lang.Object-java.lang.Object-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>putInIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;putInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</pre>
<div class="block">ADVANCED:
 Registers the Object and given key with the identity map.
 The Object must always be registered with its version number if optimistic locking is used.</div>
</li>
</ul>
<a name="putInIdentityMap-java.lang.Object-java.lang.Object-java.lang.Object-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>putInIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;putInIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue,
                        long&nbsp;readTime)</pre>
<div class="block">ADVANCED:
 Registers the given Object with the identity map.
 The Object must always be registered with its version number if optimistic locking is used.
 The readTime may also be included in the cache key as it is constructed.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dd><code>key</code> - Object</dd>
<dd><code>writeLockValue</code> - Object for versioning</dd>
<dd><code>readTime</code> - long, time in milliseconds</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object the Object put into the identity map</dd>
</dl>
</li>
</ul>
<a name="removeFromIdentityMap-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;removeFromIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject)</pre>
<div class="block">ADVANCED:
 Removes the Object from the Object cache.
 <p> NOTE: Caution should be used when calling to avoid violating Object identity.
 The application should only call this if its known that no references to the Object exist.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object the Object removed from the identity map</dd>
</dl>
</li>
</ul>
<a name="removeFromIdentityMap-java.lang.Object-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeFromIdentityMap</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;removeFromIdentityMap(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;key,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass)</pre>
<div class="block">ADVANCED:
 Removes the Object with given primary key and Class from the Object cache.
 <p> NOTE: Caution should be used when calling to avoid violating Object identity.
 The application should only call this if its known that no references to the Object exist.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Object the Object removed from the identity map</dd>
</dl>
</li>
</ul>
<a name="updateWriteLockValue-java.lang.Object-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateWriteLockValue</h4>
<pre>void&nbsp;updateWriteLockValue(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;domainObject,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</pre>
<div class="block">ADVANCED:
 Updates the write lock value in the identity map for cache key of the primary key
 the given Object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>domainObject</code> - Object</dd>
<dd><code>writeLockValue</code> - Object for versioning</dd>
</dl>
</li>
</ul>
<a name="updateWriteLockValue-java.lang.Object-java.lang.Class-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateWriteLockValue</h4>
<pre>void&nbsp;updateWriteLockValue(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;primaryKey,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;theClass,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;writeLockValue)</pre>
<div class="block">ADVANCED:
 Updates the write lock value in the cache for the Object with same primary key as the given Object.
 The write lock values is used when optimistic locking is stored in the cache instead of in the object.</div>
</li>
</ul>
<a name="validateCache--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>validateCache</h4>
<pre>void&nbsp;validateCache()</pre>
<div class="block">ADVANCED:
 This can be used to help debugging an Object identity problem.
 An Object identity problem is when an Object in the cache references an
 Object that is not in the cache. This method will validate that all cached
 Objects are in a correct state.</div>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">EclipseLink 3.0.2, API Reference</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/eclipse/persistence/sessions/ExternalTransactionController.html" title="interface in org.eclipse.persistence.sessions"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/eclipse/persistence/sessions/JNDIConnector.html" title="class in org.eclipse.persistence.sessions"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/persistence/sessions/IdentityMapAccessor.html" target="_top">Frames</a></li>
<li><a href="IdentityMapAccessor.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2007&#x2013;2021 <a href="http://www.eclipse.org/eclipselink">Eclipse.org - EclipseLink Project</a>. All rights reserved.</small></p>
</body>
</html>
