<!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_272) on Thu Nov 12 16:27:22 PST 2020 -->
<title>AttributesFactory (Apache Geode 1.13.1)</title>
<meta name="date" content="2020-11-12">
<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="AttributesFactory (Apache Geode 1.13.1)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":42,"i1":42,"i2":42,"i3":42,"i4":42,"i5":42,"i6":42,"i7":42,"i8":42,"i9":42,"i10":42,"i11":42,"i12":42,"i13":42,"i14":42,"i15":42,"i16":42,"i17":42,"i18":42,"i19":42,"i20":42,"i21":42,"i22":42,"i23":42,"i24":42,"i25":42,"i26":42,"i27":42,"i28":42,"i29":42,"i30":42,"i31":42,"i32":42,"i33":42,"i34":42,"i35":42,"i36":42,"i37":42,"i38":42,"i39":42,"i40":42,"i41":42,"i42":42,"i43":42,"i44":42,"i45":42,"i46":42,"i47":42,"i48":42,"i49":42,"i50":41};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"],32:["t6","Deprecated 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>
<div class="subNav">
<ul class="navList">
<li>Prev&nbsp;Class</li>
<li><a href="../../../../org/apache/geode/cache/AttributesMutator.html" title="interface in org.apache.geode.cache"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/geode/cache/AttributesFactory.html" target="_top">Frames</a></li>
<li><a href="AttributesFactory.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><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&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.apache.geode.cache</div>
<h2 title="Class AttributesFactory" class="title">Class AttributesFactory&lt;K,V&gt;</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.geode.cache.AttributesFactory&lt;K,V&gt;</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/Cache.html#createRegionFactory-org.apache.geode.cache.RegionShortcut-"><code>Cache.createRegionFactory(RegionShortcut)</code></a> or
             <a href="../../../../org/apache/geode/cache/client/ClientCache.html#createClientRegionFactory-org.apache.geode.cache.client.ClientRegionShortcut-"><code>ClientCache.createClientRegionFactory(ClientRegionShortcut)</code></a> instead.</span></div>
</div>
<br>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public class <span class="typeNameLabel">AttributesFactory&lt;K,V&gt;</span>
extends <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></pre>
<div class="block">Creates instances of <a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache"><code>RegionAttributes</code></a>. An <code>AttributesFactory</code> instance maintains
 state for creating <code>RegionAttributes</code> instances. The setter methods are used to change the
 settings that will be used for creating the next attributes instance with the <a href="../../../../org/apache/geode/cache/AttributesFactory.html#create--"><code>create()</code></a>
 method. If you create a factory with the default constructor, then the factory is set up to
 create attributes with all default settings. You can also create a factory by providing a
 <code>RegionAttributes</code>, which will set up the new factory with the settings provided in that
 attributes instance.

 <p>
 Once a <code>RegionAttributes</code> is created, it can only be modified after it has been used to
 create a <code>Region</code>, and then only by using an <a href="../../../../org/apache/geode/cache/AttributesMutator.html" title="interface in org.apache.geode.cache"><code>AttributesMutator</code></a> obtained from the
 region.

 <h3>Attributes</h3>
 <h4>Callbacks</h4>
 <dl>
 <dt><a href="../../../../org/apache/geode/cache/CacheLoader.html" title="interface in org.apache.geode.cache"><code>CacheLoader</code></a> [<em>default:</em> <code>null</code>, meaning no loader]</dt>
 <dd>User-implemented plug-in for loading data on cache misses.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCacheLoader-org.apache.geode.cache.CacheLoader-"><code>setCacheLoader(org.apache.geode.cache.CacheLoader&lt;K, V&gt;)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getCacheLoader--"><code>RegionAttributes.getCacheLoader()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setCacheLoader-org.apache.geode.cache.CacheLoader-"><code>AttributesMutator.setCacheLoader(org.apache.geode.cache.CacheLoader&lt;K, V&gt;)</code></a></dd>

 <dt><a href="../../../../org/apache/geode/cache/CacheWriter.html" title="interface in org.apache.geode.cache"><code>CacheWriter</code></a> [<em>default:</em> <code>null</code>, meaning no writer]</dt>
 <dd>User-implemented plug-in for intercepting cache modifications, e.g. for writing to an
 external data source.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCacheWriter-org.apache.geode.cache.CacheWriter-"><code>setCacheWriter(org.apache.geode.cache.CacheWriter&lt;K, V&gt;)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getCacheWriter--"><code>RegionAttributes.getCacheWriter()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setCacheWriter-org.apache.geode.cache.CacheWriter-"><code>AttributesMutator.setCacheWriter(org.apache.geode.cache.CacheWriter&lt;K, V&gt;)</code></a></dd>

 <dt><a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache"><code>CacheListener</code></a> [<em>default:</em> <code>null</code>, meaning no listener ]</dt>
 <dd>User-implemented plug-in for receiving and handling cache related events.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#addCacheListener-org.apache.geode.cache.CacheListener-"><code>addCacheListener(org.apache.geode.cache.CacheListener&lt;K, V&gt;)</code></a> <a href="../../../../org/apache/geode/cache/AttributesFactory.html#initCacheListeners-org.apache.geode.cache.CacheListener:A-"><code>initCacheListeners(org.apache.geode.cache.CacheListener&lt;K, V&gt;[])</code></a> <a href="../../../../org/apache/geode/cache/AttributesFactory.html#initCacheListeners-org.apache.geode.cache.CacheListener:A-"><code>initCacheListeners(org.apache.geode.cache.CacheListener&lt;K, V&gt;[])</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getCacheListeners--"><code>RegionAttributes.getCacheListeners()</code></a> <a href="../../../../org/apache/geode/cache/AttributesMutator.html#initCacheListeners-org.apache.geode.cache.CacheListener:A-"><code>AttributesMutator.initCacheListeners(org.apache.geode.cache.CacheListener&lt;K, V&gt;[])</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#addCacheListener-org.apache.geode.cache.CacheListener-"><code>AttributesMutator.addCacheListener(org.apache.geode.cache.CacheListener&lt;K, V&gt;)</code></a> <a href="../../../../org/apache/geode/cache/AttributesMutator.html#removeCacheListener-org.apache.geode.cache.CacheListener-"><code>AttributesMutator.removeCacheListener(org.apache.geode.cache.CacheListener&lt;K, V&gt;)</code></a></dd>
 </dl>
 <h4>Expiration</h4>
 <dl>
 <dt>RegionTimeToLive [<em>default:</em> no expiration]</dt>
 <dd>Expiration configuration for the entire region based on the
 <a href="../../../../org/apache/geode/cache/CacheStatistics.html#getLastModifiedTime--"><code>lastModifiedTime</code></a>.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setRegionTimeToLive-org.apache.geode.cache.ExpirationAttributes-"><code>setRegionTimeToLive(org.apache.geode.cache.ExpirationAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getRegionTimeToLive--"><code>RegionAttributes.getRegionTimeToLive()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setRegionTimeToLive-org.apache.geode.cache.ExpirationAttributes-"><code>AttributesMutator.setRegionTimeToLive(org.apache.geode.cache.ExpirationAttributes)</code></a></dd>

 <dt>RegionIdleTimeout [<em>default:</em> no expiration]</dt>
 <dd>Expiration configuration for the entire region based on the
 <a href="../../../../org/apache/geode/cache/CacheStatistics.html#getLastAccessedTime--"><code>lastAccessedTime</code></a>.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setRegionIdleTimeout-org.apache.geode.cache.ExpirationAttributes-"><code>setRegionIdleTimeout(org.apache.geode.cache.ExpirationAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getRegionIdleTimeout--"><code>RegionAttributes.getRegionIdleTimeout()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setRegionIdleTimeout-org.apache.geode.cache.ExpirationAttributes-"><code>AttributesMutator.setRegionIdleTimeout(org.apache.geode.cache.ExpirationAttributes)</code></a></dd>

 <dt>EntryTimeToLive [<em>default:</em> no expiration]</dt>
 <dd>Expiration configuration for individual entries based on the
 <a href="../../../../org/apache/geode/cache/CacheStatistics.html#getLastModifiedTime--"><code>lastModifiedTime</code></a>.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEntryTimeToLive-org.apache.geode.cache.ExpirationAttributes-"><code>setEntryTimeToLive(org.apache.geode.cache.ExpirationAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getEntryTimeToLive--"><code>RegionAttributes.getEntryTimeToLive()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setEntryTimeToLive-org.apache.geode.cache.ExpirationAttributes-"><code>AttributesMutator.setEntryTimeToLive(org.apache.geode.cache.ExpirationAttributes)</code></a></dd>

 <dt>EntryIdleTimeout [<em>default:</em> no expiration]</dt>
 <dd>Expiration configuration for individual entries based on the
 <a href="../../../../org/apache/geode/cache/CacheStatistics.html#getLastAccessedTime--"><code>lastAccessedTime</code></a>.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEntryIdleTimeout-org.apache.geode.cache.ExpirationAttributes-"><code>setEntryIdleTimeout(org.apache.geode.cache.ExpirationAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getEntryIdleTimeout--"><code>RegionAttributes.getEntryIdleTimeout()</code></a>
 <a href="../../../../org/apache/geode/cache/AttributesMutator.html#setEntryIdleTimeout-org.apache.geode.cache.ExpirationAttributes-"><code>AttributesMutator.setEntryIdleTimeout(org.apache.geode.cache.ExpirationAttributes)</code></a></dd>
 </dl>
 <h4>Distribution</h4>
 <dl>
 <dt><a href="../../../../org/apache/geode/cache/Scope.html" title="class in org.apache.geode.cache"><code>Scope</code></a>[<em>default:</em> <a href="../../../../org/apache/geode/cache/Scope.html#DISTRIBUTED_NO_ACK"><code>Scope.DISTRIBUTED_NO_ACK</code></a>]</dt>
 <dd>Properties of distribution for the region, including whether it is distributed at all,
 whether acknowledgements are required, and whether distributed synchronization is required. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setScope-org.apache.geode.cache.Scope-"><code>setScope(org.apache.geode.cache.Scope)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getScope--"><code>RegionAttributes.getScope()</code></a></dd>

 <dt>EarlyAck [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not acks required by <code>Scope.DISTRIBUTED_ACK</code> are sent after an operation is
 processed. If <code>true</code> then remote caches will ACK before processing an operation sent by the
 cache that has set earlyAck to <code>true</code>. Note that this attribute is only meaningful on the
 cache that is initiating an operation; it does not matter what it is set to on the cache that
 receives the operation.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEarlyAck-boolean-"><code>setEarlyAck(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getEarlyAck--"><code>RegionAttributes.getEarlyAck()</code></a></dd>

 <dt><a href="../../../../org/apache/geode/cache/SubscriptionAttributes.html" title="class in org.apache.geode.cache"><code>SubscriptionAttributes</code></a> [<em>default:</em> <a href="../../../../org/apache/geode/cache/InterestPolicy.html#DEFAULT"><code>InterestPolicy.DEFAULT</code></a>]</dt>
 <dd>How will the region in this cache subscribe to other distributed instances of this region.
 <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setSubscriptionAttributes-org.apache.geode.cache.SubscriptionAttributes-"><code>setSubscriptionAttributes(org.apache.geode.cache.SubscriptionAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getSubscriptionAttributes--"><code>RegionAttributes.getSubscriptionAttributes()</code></a></dd>

 <dt>EnableAsyncConflation [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not conflation is enabled for sending messages to async peers. Async peers are
 those whose <code>async-distribution-timeout</code> gemfire.property is greater than zero.
 AsyncConflation is ignored if the scope is <code>DISTRIBUTED_ACK</code> or <code>GLOBAL</code>. Conflation
 is only done on entry update operations. It is done by dropping the earlier update from the
 message queue. <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableAsyncConflation-boolean-"><code>setEnableAsyncConflation(boolean)</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getEnableAsyncConflation--"><code>RegionAttributes.getEnableAsyncConflation()</code></a></dd>
 <dt>poolName [<em>default:</em> <code>null</code>, meaning no pool]</dt>
 <dd>Whether or not this region is a client that is to use connections from the named pool to
 communicate with servers. If <code>null</code>, then it is not a client. If <code>non-null</code>, then the
 named pool will be used. <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPoolName-java.lang.String-"><code>setPoolName(java.lang.String)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getPoolName--"><code>RegionAttributes.getPoolName()</code></a></dd>


 <dt>EnableSubscriptionConflation [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not conflation is enabled for sending messages from a cache server to its clients.
 Note: This parameter is only valid for cache server to client communication. It has no effect in
 peer to peer communication. If <code>true</code>, messages will be conflated before they are sent from
 a cache server to its clients. Only the latest value will be sent. Note that this attribute is
 only meaningful in a client server topology. <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-"><code>setEnableSubscriptionConflation(boolean)</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getEnableSubscriptionConflation--"><code>RegionAttributes.getEnableSubscriptionConflation()</code></a></dd>
 <dt>Publisher [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not a region is a publisher. Publishers are regions that will have distributed
 write operations done on them. If a publisher is also a replicate then it will be used as the
 preferred source for initializing other replicates. <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPublisher-boolean-"><code>setPublisher(boolean)</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getPublisher--"><code>RegionAttributes.getPublisher()</code></a></dd>
 <dt>isCloningEnabled [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not value is cloned before appling <code>Delta</code>s If <code>false</code>, value will not
 be cloned <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCloningEnabled-boolean-"><code>setCloningEnabled(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getCloningEnabled--"><code>RegionAttributes.getCloningEnabled()</code></a></dd></dt>
 </dl>
 <h4>Storage (see also <a href="package-summary.html#storage">package summary </a>)</h4>
 <dl>
 <dt><a href="../../../../org/apache/geode/cache/DataPolicy.html" title="class in org.apache.geode.cache"><code>DataPolicy</code></a> [<em>default:</em> <code>DataPolicy.NORMAL</code>]</dt>
 <dd>Specifies the data storage policy.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDataPolicy-org.apache.geode.cache.DataPolicy-"><code>setDataPolicy(org.apache.geode.cache.DataPolicy)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getDataPolicy--"><code>RegionAttributes.getDataPolicy()</code></a></dd>

 <dt><a href="../../../../org/apache/geode/cache/MirrorType.html" title="class in org.apache.geode.cache"><code>MirrorType</code></a> [<em>default:</em> <code>MirrorType.NONE</code>]</dt>
 <dd><em>Deprecated</em>, use DataPolicy instead.</dd>

 <dt><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEvictionAttributes-org.apache.geode.cache.EvictionAttributes-"><code>EvictionAttributes</code></a></dt>
 <dd><a href="../../../../org/apache/geode/cache/EvictionAttributes.html" title="class in org.apache.geode.cache"><code>EvictionAttributes</code></a> are the replacement for the deprecated and removed
 CapacityController interface. EvictionAttributes describe the <a href="../../../../org/apache/geode/cache/EvictionAlgorithm.html" title="class in org.apache.geode.cache"><code>EvictionAlgorithm</code></a> and the
 <a href="../../../../org/apache/geode/cache/EvictionAction.html" title="class in org.apache.geode.cache"><code>EvictionAction</code></a> as well as the various conditions under which the algorithm perform the
 action e.g. when the maximum number of entries has been reached or the maximum percentage of JVM
 heap has been consumed. Setting <code>EvictionAttributes</code> installs an eviction controller on the
 Region instantiated with the associated RegionAttributes</dd>

 <dt>KeyConstraint [<em>default:</em> <code>null</code>, meaning no constraint]</dt>
 <dd>The Class to constrain the keys to in the region.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setKeyConstraint-java.lang.Class-"><code>setKeyConstraint(java.lang.Class&lt;K&gt;)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getKeyConstraint--"><code>RegionAttributes.getKeyConstraint()</code></a></dd>

 <dt>ValueConstraint [<em>default:</em> <code>null</code>, meaning no constraint]</dt>
 <dd>The Class to constrain the values to in the region. In addition to the utility of this for
 applications in general, a <code>valueConstraint</code> is helpful for compiling queries.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setValueConstraint-java.lang.Class-"><code>setValueConstraint(java.lang.Class&lt;V&gt;)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getValueConstraint--"><code>RegionAttributes.getValueConstraint()</code></a></dd>

 <dt>InitialCapacity [<em>default:</em> <code>16</code>]</dt>
 <dd>The initial capacity of the map used for storing the entries. <br>
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util"><code>HashMap</code></a> <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setInitialCapacity-int-"><code>setInitialCapacity(int)</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getInitialCapacity--"><code>RegionAttributes.getInitialCapacity()</code></a></dd>

 <dt>LoadFactor [<em>default:</em> <code>0.75</code>]</dt>
 <dd>The load factor of the map used for storing the entries. <br>
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util"><code>HashMap</code></a> <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setLoadFactor-float-"><code>setLoadFactor(float)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getLoadFactor--"><code>RegionAttributes.getLoadFactor()</code></a></dd>

 <dt>ConcurrencyLevel [<em>default:</em> <code>16</code>]</dt>
 <dd>The allowed concurrency among updates to values in the region is guided by the
 <tt>concurrencyLevel</tt>, which is used as a hint for internal sizing. The actual concurrency
 will vary. Ideally, you should choose a value to accommodate as many threads as will ever
 concurrently modify values in the region. Using a significantly higher value than you need can
 waste space and time, and a significantly lower value can lead to thread contention. But
 overestimates and underestimates within an order of magnitude do not usually have much noticeable
 impact. A value of one is appropriate when it is known that only one thread will modify and all
 others will only read. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setConcurrencyLevel-int-"><code>setConcurrencyLevel(int)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getConcurrencyLevel--"><code>RegionAttributes.getConcurrencyLevel()</code></a></dd>

 <dt>ConcurrencyChecksEnabled [<em>default:</em> <code>true</code>]</dt>
 <dd>Enables a distributed versioning algorithm that detects concurrency conflicts in regions and
 ensures that changes to an entry are not applied in a different order in other members. This can
 cause operations to be conflated, so that some cache listeners may see an event while others do
 not, but it guarantees that the system will be consistent.</dd>

 <dt>StatisticsEnabled [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether statistics are enabled for this region. The default is disabled, which conserves on
 memory. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setStatisticsEnabled-boolean-"><code>setStatisticsEnabled(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getStatisticsEnabled--"><code>RegionAttributes.getStatisticsEnabled()</code></a></dd>

 <dt>IgnoreJTA [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether JTA transactions are ignored for this region. The default is to look for and join JTA
 transactions for operations performed on a region.

 <dt>DiskStoreName [<em>default:</em> <code>null</code>, meaning no disk store]</dt>
 <dd>If not <code>null</code> then this region will write its data to the named <a href="../../../../org/apache/geode/cache/DiskStore.html" title="interface in org.apache.geode.cache"><code>DiskStore</code></a>.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getDiskStoreName--"><code>RegionAttributes.getDiskStoreName()</code></a></dd>

 <dt>DiskSynchronous [<em>default:</em> <code>true</code>]</dt>
 <dd>If <code>true</code> then any writes to disk done for this region will be done synchronously. This
 means that they will be in the file system buffer before the operation doing the write
 returns.<br>
 If <code>false</code> then any writes to disk done for this region will be done asynchronously. This
 means that they are queued up to be written and when they are actually written to the file system
 buffer is determined by the region's <a href="../../../../org/apache/geode/cache/DiskStore.html" title="interface in org.apache.geode.cache"><code>DiskStore</code></a> configuration. Asynchronous writes will be
 conflated if the same entry is written while a previous operation for the same entry is still in
 the queue.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskSynchronous-boolean-"><code>setDiskSynchronous(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#isDiskSynchronous--"><code>RegionAttributes.isDiskSynchronous()</code></a></dd>

 <dt>PersistBackup [<em>default:</em> <code>false</code>]</dt>
 <dd>Whether or not a persistent backup should be made of the region.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPersistBackup-boolean-"><code>setPersistBackup(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getPersistBackup--"><code>RegionAttributes.getPersistBackup()</code></a></dd>
 <dd><em>Deprecated</em>, use <a href="../../../../org/apache/geode/cache/DataPolicy.html#PERSISTENT_REPLICATE"><code>DataPolicy.PERSISTENT_REPLICATE</code></a> or
 <a href="../../../../org/apache/geode/cache/DataPolicy.html#PERSISTENT_PARTITION"><code>DataPolicy.PERSISTENT_PARTITION</code></a> instead.</dd>

 <dt>DiskWriteAttributes [<em>default:</em> Asynchronously write to disk every second (a
 <code>timeInterval</code> of 1000 and a <code>byteThreshold</code> of 0). <code>rollOplogs</code> is set to true
 and <code>maxOplogSize</code> is set to 1024 MB]</dt>
 <dd>How region data should be written to disk. Determines whether data should be written
 synchronously or asynchronously. Data that is written asynchronously can be written at a certain
 <a href="../../../../org/apache/geode/cache/DiskWriteAttributes.html#getTimeInterval--">time interval</a> or once a certain number of
 <a href="../../../../org/apache/geode/cache/DiskWriteAttributes.html#getBytesThreshold--">bytes of data</a> have been enqueued.<br>
 <a href="../../../../org/apache/geode/cache/DiskWriteAttributes.html" title="interface in org.apache.geode.cache"><code>DiskWriteAttributes</code></a> <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskWriteAttributes-org.apache.geode.cache.DiskWriteAttributes-"><code>setDiskWriteAttributes(org.apache.geode.cache.DiskWriteAttributes)</code></a>
 <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getDiskWriteAttributes--"><code>RegionAttributes.getDiskWriteAttributes()</code></a></dd>
 <dd><em>Deprecated</em>, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> and <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskSynchronous-boolean-"><code>setDiskSynchronous(boolean)</code></a>
 instead.</dd>

 <dt>DiskDirs [<em>default:</em> Current working directory (<code>user.dir</code>
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/System.html?is-external=true#getProperties--" title="class or interface in java.lang">system property</a>)]</dt>
 <dd>The directories to which the region's data are written. If multiple directories are used,
 GemFire will attempt to distribute the data evenly among them. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskDirs-java.io.File:A-"><code>setDiskDirs(java.io.File[])</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getDiskDirs--"><code>RegionAttributes.getDiskDirs()</code></a></dd>
 <dd><em>Deprecated</em>, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> instead.</dd>

 <dt>DiskDirSizes [<em>default:</em> 10240 MB]</dt>
 <dd>The size of the directory to which region's data is written.<br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskDirsAndSizes-java.io.File:A-int:A-"><code>setDiskDirsAndSizes(java.io.File[], int[])</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getDiskDirSizes--"><code>RegionAttributes.getDiskDirSizes()</code></a></dd>
 <dd><em>Deprecated</em>, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> instead.</dd>


 <dt><a href="../../../../org/apache/geode/cache/PartitionAttributes.html" title="interface in org.apache.geode.cache"><code>PartitionAttributes</code></a> [<em>default:</em> <code>null</code>, meaning no region
 partitioning]</dt>
 <dd>How region data is partitioned among the members of the distributed system. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPartitionAttributes-org.apache.geode.cache.PartitionAttributes-"><code>setPartitionAttributes(org.apache.geode.cache.PartitionAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getPartitionAttributes--"><code>RegionAttributes.getPartitionAttributes()</code></a></dd>

 <dt><a href="../../../../org/apache/geode/cache/MembershipAttributes.html" title="class in org.apache.geode.cache"><code>MembershipAttributes</code></a> [<em>default:</em> no required roles]</dt>
 <dd>How access to the region is affected when one or more required roles are missing from the
 region membership. <br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setMembershipAttributes-org.apache.geode.cache.MembershipAttributes-"><code>setMembershipAttributes(org.apache.geode.cache.MembershipAttributes)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getMembershipAttributes--"><code>RegionAttributes.getMembershipAttributes()</code></a></dd>
 <dd><em>Deprecated</em>, this API is scheduled to be removed</dd></dt>
 </dl>

 <h4>Locking</h4>
 <dl>
 <dt>LockGrantor [<em>default:</em> <code>false</code>]</dt>
 <dd>Should this process become lock grantor for the region?</dd><br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setLockGrantor-boolean-"><code>setLockGrantor(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#isLockGrantor--"><code>RegionAttributes.isLockGrantor()</code></a> <a href="../../../../org/apache/geode/cache/Region.html#becomeLockGrantor--"><code>Region.becomeLockGrantor()</code></a>
 </dl>

 <h4>Querying</h4>
 <dl>
 <dt>IndexMaintenanceSynchronous [<em>default:</em> <code>false</code>]</dt>
 <dd>Are indexes built over in this region updated synchronously when the underlying data is
 modified?</dd><br>
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setIndexMaintenanceSynchronous-boolean-"><code>setIndexMaintenanceSynchronous(boolean)</code></a> <a href="../../../../org/apache/geode/cache/RegionAttributes.html#getIndexMaintenanceSynchronous--"><code>RegionAttributes.getIndexMaintenanceSynchronous()</code></a>
 </dl>

 <p>
 Note that the RegionAttributes are not distributed with the region.

 <a name="compatibility">
 <h3>Compatibility Rules</h3>
 <h4>RegionAttributes Creation Constraints</h4> If any of the following compatibility rules are
 violated when <a href="../../../../org/apache/geode/cache/AttributesFactory.html#create--"><code>create()</code></a>} is called then an <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang"><code>IllegalStateException</code></a> is thrown. See
 <a href="../../../../org/apache/geode/cache/AttributesFactory.html#validateAttributes-org.apache.geode.cache.RegionAttributes-"><code>validateAttributes(org.apache.geode.cache.RegionAttributes&lt;?, ?&gt;)</code></a>.

 <a name="creationConstraints">
 <h3>Creation Constraints</h3>
 <h4>Region Creation Constraints on RegionAttributes</h4>

 If any of the following rules are violated when <a href="../../../../org/apache/geode/cache/Region.html#createSubregion-java.lang.String-org.apache.geode.cache.RegionAttributes-"><code>createSubregion</code></a> or
 <a href="../../../../org/apache/geode/cache/Cache.html#createRegion-java.lang.String-org.apache.geode.cache.RegionAttributes-"><code>createRegion</code></a> are called, then an <code>IllegalStateException</code> is
 thrown.

 <ul>
 <li>A region with <code>Scope.LOCAL</code> can only have subregions with <code>Scope.LOCAL</code>.</li>
 <li><code>Scope.GLOBAL</code> is illegal if there is any other cache in the distributed system that
 has the same region with <code>Scope.DISTRIBUTED_NO_ACK</code> or <code>Scope.DISTRIBUTED_ACK</code>.</li>
 <li><code>Scope.DISTRIBUTED_ACK</code> is illegal if there is any other cache in the distributed
 system that has the same region with <code>Scope.DISTRIBUTED_NO_ACK</code> or
 <code>Scope.GLOBAL</code>.</li>
 <li><code>Scope.DISTRIBUTED_NO_ACK</code> is illegal if there is any other cache in the distributed
 system that has the same region with <code>Scope.DISTRIBUTED_ACK</code> or <code>Scope.GLOBAL</code>.</li>
 </ul></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 3.0</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache"><code>RegionAttributes</code></a>, 
<a href="../../../../org/apache/geode/cache/AttributesMutator.html" title="interface in org.apache.geode.cache"><code>AttributesMutator</code></a>, 
<a href="../../../../org/apache/geode/cache/Region.html#createSubregion-java.lang.String-org.apache.geode.cache.RegionAttributes-"><code>Region.createSubregion(String, RegionAttributes)</code></a></dd>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#DEFAULT_CONCURRENCY_LEVEL">DEFAULT_CONCURRENCY_LEVEL</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The default concurrency level for updates to region values</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#DEFAULT_DISK_SYNCHRONOUS">DEFAULT_DISK_SYNCHRONOUS</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The default disk synchronous write setting</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#AttributesFactory--">AttributesFactory</a></span>()</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a new instance of AttributesFactory ready to create a <code>RegionAttributes</code> with
 default settings.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#AttributesFactory-org.apache.geode.cache.RegionAttributes-">AttributesFactory</a></span>(<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;regionAttributes)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a new instance of AttributesFactory ready to create a <code>RegionAttributes</code> with the
 same settings as those in the specified <code>RegionAttributes</code>.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== 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="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></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="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t6" class="tableTab"><span><a href="javascript:show(32);">Deprecated 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/apache/geode/cache/AttributesFactory.html#addAsyncEventQueueId-java.lang.String-">addAsyncEventQueueId</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;asyncEventQueueId)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Adds a AsyncEventQueue to the end of list of async event queues on this factory</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/apache/geode/cache/AttributesFactory.html#addCacheListener-org.apache.geode.cache.CacheListener-">addCacheListener</a></span>(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;aListener)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Adds a cache listener to the end of the list of cache listeners on this factory.</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/apache/geode/cache/AttributesFactory.html#addGatewaySenderId-java.lang.String-">addGatewaySenderId</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;gatewaySenderId)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">adds a gateway sender to the end of list of gateway senders on this factory</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#create--">create</a></span>()</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a <code>RegionAttributes</code> with the current settings.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#createRegionAttributes--">createRegionAttributes</a></span>()</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#create--"><code>create()</code></a> instead</span></div>
</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#initCacheListeners-org.apache.geode.cache.CacheListener:A-">initCacheListeners</a></span>(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;[]&nbsp;newListeners)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Removes all cache listeners and then adds each listener in the specified array.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setBucketRegion-boolean-">setBucketRegion</a></span>(boolean&nbsp;b)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
&nbsp;</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCacheListener-org.apache.geode.cache.CacheListener-">setCacheListener</a></span>(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;aListener)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#addCacheListener-org.apache.geode.cache.CacheListener-"><code>addCacheListener(org.apache.geode.cache.CacheListener&lt;K, V&gt;)</code></a> instead.</span></div>
</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCacheLoader-org.apache.geode.cache.CacheLoader-">setCacheLoader</a></span>(<a href="../../../../org/apache/geode/cache/CacheLoader.html" title="interface in org.apache.geode.cache">CacheLoader</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;cacheLoader)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the cache loader for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCacheWriter-org.apache.geode.cache.CacheWriter-">setCacheWriter</a></span>(<a href="../../../../org/apache/geode/cache/CacheWriter.html" title="interface in org.apache.geode.cache">CacheWriter</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;cacheWriter)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the cache writer for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCloningEnabled-boolean-">setCloningEnabled</a></span>(boolean&nbsp;cloningEnable)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets cloning on region.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCompressor-org.apache.geode.compression.Compressor-">setCompressor</a></span>(<a href="../../../../org/apache/geode/compression/Compressor.html" title="interface in org.apache.geode.compression">Compressor</a>&nbsp;compressor)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets this region's compressor for compressing entry values.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setConcurrencyChecksEnabled-boolean-">setConcurrencyChecksEnabled</a></span>(boolean&nbsp;concurrencyChecksEnabled)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Enables or disabled concurrent modification checks.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setConcurrencyLevel-int-">setConcurrencyLevel</a></span>(int&nbsp;concurrencyLevel)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the concurrency level of the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCustomEntryIdleTimeout-org.apache.geode.cache.CustomExpiry-">setCustomEntryIdleTimeout</a></span>(<a href="../../../../org/apache/geode/cache/CustomExpiry.html" title="interface in org.apache.geode.cache">CustomExpiry</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;custom)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout CustomExpiry for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setCustomEntryTimeToLive-org.apache.geode.cache.CustomExpiry-">setCustomEntryTimeToLive</a></span>(<a href="../../../../org/apache/geode/cache/CustomExpiry.html" title="interface in org.apache.geode.cache">CustomExpiry</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;custom)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the custom timeToLive for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDataPolicy-org.apache.geode.cache.DataPolicy-">setDataPolicy</a></span>(<a href="../../../../org/apache/geode/cache/DataPolicy.html" title="class in org.apache.geode.cache">DataPolicy</a>&nbsp;dataPolicy)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the data policy for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskDirs-java.io.File:A-">setDiskDirs</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html?is-external=true" title="class or interface in java.io">File</a>[]&nbsp;diskDirs)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/DiskStoreFactory.html#setDiskDirs-java.io.File:A-"><code>DiskStoreFactory.setDiskDirs(java.io.File[])</code></a> instead</span></div>
</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskDirsAndSizes-java.io.File:A-int:A-">setDiskDirsAndSizes</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html?is-external=true" title="class or interface in java.io">File</a>[]&nbsp;diskDirs,
                   int[]&nbsp;diskSizes)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/DiskStoreFactory.html#setDiskDirsAndSizes-java.io.File:A-int:A-"><code>DiskStoreFactory.setDiskDirsAndSizes(java.io.File[], int[])</code></a> instead</span></div>
</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-">setDiskStoreName</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;name)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the DiskStore name attribute.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskSynchronous-boolean-">setDiskSynchronous</a></span>(boolean&nbsp;isSynchronous)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not the writing to the disk is synchronous.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskWriteAttributes-org.apache.geode.cache.DiskWriteAttributes-">setDiskWriteAttributes</a></span>(<a href="../../../../org/apache/geode/cache/DiskWriteAttributes.html" title="interface in org.apache.geode.cache">DiskWriteAttributes</a>&nbsp;attrs)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> instead</span></div>
</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/apache/geode/cache/AttributesFactory.html#setEarlyAck-boolean-">setEarlyAck</a></span>(boolean&nbsp;earlyAck)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">This setting no longer has any effect.</span></div>
</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/apache/geode/cache/AttributesFactory.html#setEnableAsyncConflation-boolean-">setEnableAsyncConflation</a></span>(boolean&nbsp;enableAsyncConflation)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not conflation is enabled for sending messages to async peers.</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/apache/geode/cache/AttributesFactory.html#setEnableBridgeConflation-boolean-">setEnableBridgeConflation</a></span>(boolean&nbsp;enableBridgeConflation)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 5.7 use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-"><code>setEnableSubscriptionConflation(boolean)</code></a> instead.</span></div>
</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/apache/geode/cache/AttributesFactory.html#setEnableConflation-boolean-">setEnableConflation</a></span>(boolean&nbsp;enableBridgeConflation)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-"><code>setEnableSubscriptionConflation(boolean)</code></a></span></div>
</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/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-">setEnableSubscriptionConflation</a></span>(boolean&nbsp;enableSubscriptionConflation)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not conflation is enabled for sending messages from a cache server to its
 clients.</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/apache/geode/cache/AttributesFactory.html#setEntryIdleTimeout-org.apache.geode.cache.ExpirationAttributes-">setEntryIdleTimeout</a></span>(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;idleTimeout)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout expiration attributes for region entries for the next
 <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setEntryTimeToLive-org.apache.geode.cache.ExpirationAttributes-">setEntryTimeToLive</a></span>(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;timeToLive)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the timeToLive expiration attributes for region entries for the next
 <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setEvictionAttributes-org.apache.geode.cache.EvictionAttributes-">setEvictionAttributes</a></span>(<a href="../../../../org/apache/geode/cache/EvictionAttributes.html" title="class in org.apache.geode.cache">EvictionAttributes</a>&nbsp;evictAttrs)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the EvictionController for the next <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setIgnoreJTA-boolean-">setIgnoreJTA</a></span>(boolean&nbsp;flag)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the flag telling a region to ignore JTA transactions.</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/apache/geode/cache/AttributesFactory.html#setIndexMaintenanceSynchronous-boolean-">setIndexMaintenanceSynchronous</a></span>(boolean&nbsp;synchronous)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Set how indexes on the region should be maintained.</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/apache/geode/cache/AttributesFactory.html#setInitialCapacity-int-">setInitialCapacity</a></span>(int&nbsp;initialCapacity)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the entry initial capacity for the next <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setKeyConstraint-java.lang.Class-">setKeyConstraint</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>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>&gt;&nbsp;keyConstraint)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the key constraint for the next <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setLoadFactor-float-">setLoadFactor</a></span>(float&nbsp;loadFactor)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the entry load factor for the next <code>RegionAttributes</code> created.</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/apache/geode/cache/AttributesFactory.html#setLockGrantor-boolean-">setLockGrantor</a></span>(boolean&nbsp;isLockGrantor)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether this region should become lock grantor.</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/apache/geode/cache/AttributesFactory.html#setMembershipAttributes-org.apache.geode.cache.MembershipAttributes-">setMembershipAttributes</a></span>(<a href="../../../../org/apache/geode/cache/MembershipAttributes.html" title="class in org.apache.geode.cache">MembershipAttributes</a>&nbsp;membership)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">this API is scheduled to be removed</span></div>
</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/apache/geode/cache/AttributesFactory.html#setMirrorType-org.apache.geode.cache.MirrorType-">setMirrorType</a></span>(<a href="../../../../org/apache/geode/cache/MirrorType.html" title="class in org.apache.geode.cache">MirrorType</a>&nbsp;mirrorType)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDataPolicy-org.apache.geode.cache.DataPolicy-"><code>setDataPolicy(org.apache.geode.cache.DataPolicy)</code></a> instead.</span></div>
</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/apache/geode/cache/AttributesFactory.html#setMulticastEnabled-boolean-">setMulticastEnabled</a></span>(boolean&nbsp;value)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether distributed operations on this region should attempt to use multicast.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setOffHeap-boolean-">setOffHeap</a></span>(boolean&nbsp;offHeap)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Enables this region's usage of off-heap memory if true.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPartitionAttributes-org.apache.geode.cache.PartitionAttributes-">setPartitionAttributes</a></span>(<a href="../../../../org/apache/geode/cache/PartitionAttributes.html" title="interface in org.apache.geode.cache">PartitionAttributes</a>&nbsp;partition)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the <code>PartitionAttributes</code> that describe how the region is partitioned among members
 of the distributed system.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPersistBackup-boolean-">setPersistBackup</a></span>(boolean&nbsp;persistBackup)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/DataPolicy.html#PERSISTENT_REPLICATE"><code>DataPolicy.PERSISTENT_REPLICATE</code></a> instead</span></div>
</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/apache/geode/cache/AttributesFactory.html#setPoolName-java.lang.String-">setPoolName</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;name)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the pool name attribute.</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/apache/geode/cache/AttributesFactory.html#setPublisher-boolean-">setPublisher</a></span>(boolean&nbsp;v)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">as of 6.5</span></div>
</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/apache/geode/cache/AttributesFactory.html#setRegionIdleTimeout-org.apache.geode.cache.ExpirationAttributes-">setRegionIdleTimeout</a></span>(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;idleTimeout)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout expiration attributes for the region itself for the next
 <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setRegionTimeToLive-org.apache.geode.cache.ExpirationAttributes-">setRegionTimeToLive</a></span>(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;timeToLive)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the timeToLive expiration attributes for the region itself for the next
 <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setScope-org.apache.geode.cache.Scope-">setScope</a></span>(<a href="../../../../org/apache/geode/cache/Scope.html" title="class in org.apache.geode.cache">Scope</a>&nbsp;scopeType)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the scope for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setStatisticsEnabled-boolean-">setStatisticsEnabled</a></span>(boolean&nbsp;statisticsEnabled)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether statistics are enabled for this region and its entries.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setSubscriptionAttributes-org.apache.geode.cache.SubscriptionAttributes-">setSubscriptionAttributes</a></span>(<a href="../../../../org/apache/geode/cache/SubscriptionAttributes.html" title="class in org.apache.geode.cache">SubscriptionAttributes</a>&nbsp;subscription)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the <code>SubscriptionAttributes</code> that describe how the region will subscribe to other
 distributed cache instances of the region.</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#setValueConstraint-java.lang.Class-">setValueConstraint</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>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;valueConstraint)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the value constraint for the next <code>RegionAttributes</code> created.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/geode/cache/AttributesFactory.html#validateAttributes-org.apache.geode.cache.RegionAttributes-">validateAttributes</a></span>(<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;?,?&gt;&nbsp;attrs)</code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Validates that the attributes are consistent with each other.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<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></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone--" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode--" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString--" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="DEFAULT_DISK_SYNCHRONOUS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEFAULT_DISK_SYNCHRONOUS</h4>
<pre>public static final&nbsp;boolean DEFAULT_DISK_SYNCHRONOUS</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The default disk synchronous write setting
 <p>
 Current value: <code>true</code> each.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 6.5</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../constant-values.html#org.apache.geode.cache.AttributesFactory.DEFAULT_DISK_SYNCHRONOUS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEFAULT_CONCURRENCY_LEVEL">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>DEFAULT_CONCURRENCY_LEVEL</h4>
<pre>public static final&nbsp;int DEFAULT_CONCURRENCY_LEVEL</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">The default concurrency level for updates to region values</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../constant-values.html#org.apache.geode.cache.AttributesFactory.DEFAULT_CONCURRENCY_LEVEL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="AttributesFactory--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>AttributesFactory</h4>
<pre>public&nbsp;AttributesFactory()</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a new instance of AttributesFactory ready to create a <code>RegionAttributes</code> with
 default settings.</div>
</li>
</ul>
<a name="AttributesFactory-org.apache.geode.cache.RegionAttributes-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>AttributesFactory</h4>
<pre>public&nbsp;AttributesFactory(<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;regionAttributes)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a new instance of AttributesFactory ready to create a <code>RegionAttributes</code> with the
 same settings as those in the specified <code>RegionAttributes</code>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>regionAttributes</code> - the <code>RegionAttributes</code> used to initialize this AttributesFactory</dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="setCacheLoader-org.apache.geode.cache.CacheLoader-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCacheLoader</h4>
<pre>public&nbsp;void&nbsp;setCacheLoader(<a href="../../../../org/apache/geode/cache/CacheLoader.html" title="interface in org.apache.geode.cache">CacheLoader</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;cacheLoader)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the cache loader for the next <code>RegionAttributes</code> created.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cacheLoader</code> - the cache loader or null if no loader</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang">IllegalStateException</a></code> - if this region has a <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPoolName-java.lang.String-"><code>pool name set</code></a></dd>
</dl>
</li>
</ul>
<a name="setCacheWriter-org.apache.geode.cache.CacheWriter-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCacheWriter</h4>
<pre>public&nbsp;void&nbsp;setCacheWriter(<a href="../../../../org/apache/geode/cache/CacheWriter.html" title="interface in org.apache.geode.cache">CacheWriter</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;cacheWriter)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the cache writer for the next <code>RegionAttributes</code> created.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cacheWriter</code> - the cache writer or null if no cache writer</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang">IllegalStateException</a></code> - if this region has a <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setPoolName-java.lang.String-"><code>pool name set</code></a></dd>
</dl>
</li>
</ul>
<a name="setCacheListener-org.apache.geode.cache.CacheListener-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCacheListener</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setCacheListener(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;aListener)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#addCacheListener-org.apache.geode.cache.CacheListener-"><code>addCacheListener(org.apache.geode.cache.CacheListener&lt;K, V&gt;)</code></a> instead.</span></div>
<div class="block">Sets the CacheListener for the next <code>RegionAttributes</code> created. Any existing cache
 listeners on this factory are removed.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>aListener</code> - a user defined CacheListener, null if no listener</dd>
</dl>
</li>
</ul>
<a name="addCacheListener-org.apache.geode.cache.CacheListener-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addCacheListener</h4>
<pre>public&nbsp;void&nbsp;addCacheListener(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;aListener)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Adds a cache listener to the end of the list of cache listeners on this factory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>aListener</code> - the cache listener to add to the factory.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if <code>aListener</code> is null</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="initCacheListeners-org.apache.geode.cache.CacheListener:A-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initCacheListeners</h4>
<pre>public&nbsp;void&nbsp;initCacheListeners(<a href="../../../../org/apache/geode/cache/CacheListener.html" title="interface in org.apache.geode.cache">CacheListener</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;[]&nbsp;newListeners)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Removes all cache listeners and then adds each listener in the specified array.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>newListeners</code> - a possibly null or empty array of listeners to add to this factory.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if the <code>newListeners</code> array has a null element</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="setEntryIdleTimeout-org.apache.geode.cache.ExpirationAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEntryIdleTimeout</h4>
<pre>public&nbsp;void&nbsp;setEntryIdleTimeout(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;idleTimeout)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout expiration attributes for region entries for the next
 <code>RegionAttributes</code> created. Default is 0 which indicates no expiration of this type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>idleTimeout</code> - the idleTimeout ExpirationAttributes for entries in this region</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if idleTimeout is null</dd>
</dl>
</li>
</ul>
<a name="setCustomEntryIdleTimeout-org.apache.geode.cache.CustomExpiry-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCustomEntryIdleTimeout</h4>
<pre>public&nbsp;void&nbsp;setCustomEntryIdleTimeout(<a href="../../../../org/apache/geode/cache/CustomExpiry.html" title="interface in org.apache.geode.cache">CustomExpiry</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;custom)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout CustomExpiry for the next <code>RegionAttributes</code> created.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>custom</code> - the CustomExpiry to use; null means none will be used.</dd>
</dl>
</li>
</ul>
<a name="setEntryTimeToLive-org.apache.geode.cache.ExpirationAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEntryTimeToLive</h4>
<pre>public&nbsp;void&nbsp;setEntryTimeToLive(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;timeToLive)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the timeToLive expiration attributes for region entries for the next
 <code>RegionAttributes</code> created. Default is 0 which indicates no expiration of this type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>timeToLive</code> - the timeToLive ExpirationAttributes for entries in this region</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if timeToLive is null</dd>
</dl>
</li>
</ul>
<a name="setCustomEntryTimeToLive-org.apache.geode.cache.CustomExpiry-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCustomEntryTimeToLive</h4>
<pre>public&nbsp;void&nbsp;setCustomEntryTimeToLive(<a href="../../../../org/apache/geode/cache/CustomExpiry.html" title="interface in org.apache.geode.cache">CustomExpiry</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;custom)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the custom timeToLive for the next <code>RegionAttributes</code> created.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>custom</code> - the CustomExpiry to use, none if the default for the region is to be used.</dd>
</dl>
</li>
</ul>
<a name="setRegionIdleTimeout-org.apache.geode.cache.ExpirationAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setRegionIdleTimeout</h4>
<pre>public&nbsp;void&nbsp;setRegionIdleTimeout(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;idleTimeout)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the idleTimeout expiration attributes for the region itself for the next
 <code>RegionAttributes</code> created. Default is 0 which indicates no expiration of this type is
 set.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>idleTimeout</code> - the ExpirationAttributes for this region idleTimeout</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if idleTimeout is null</dd>
</dl>
</li>
</ul>
<a name="setRegionTimeToLive-org.apache.geode.cache.ExpirationAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setRegionTimeToLive</h4>
<pre>public&nbsp;void&nbsp;setRegionTimeToLive(<a href="../../../../org/apache/geode/cache/ExpirationAttributes.html" title="class in org.apache.geode.cache">ExpirationAttributes</a>&nbsp;timeToLive)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the timeToLive expiration attributes for the region itself for the next
 <code>RegionAttributes</code> created. Default is 0 i.e. no expiration of this type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>timeToLive</code> - the ExpirationAttributes for this region timeToLive</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if timeToLive is null</dd>
</dl>
</li>
</ul>
<a name="setScope-org.apache.geode.cache.Scope-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setScope</h4>
<pre>public&nbsp;void&nbsp;setScope(<a href="../../../../org/apache/geode/cache/Scope.html" title="class in org.apache.geode.cache">Scope</a>&nbsp;scopeType)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the scope for the next <code>RegionAttributes</code> created. Default scope is
 DISTRIBUTED_NO_ACK. Refer gemfire documentation for more details on this.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>scopeType</code> - the type of Scope to use for the region</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if scopeType is null</dd>
</dl>
</li>
</ul>
<a name="setEvictionAttributes-org.apache.geode.cache.EvictionAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEvictionAttributes</h4>
<pre>public&nbsp;void&nbsp;setEvictionAttributes(<a href="../../../../org/apache/geode/cache/EvictionAttributes.html" title="class in org.apache.geode.cache">EvictionAttributes</a>&nbsp;evictAttrs)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the EvictionController for the next <code>RegionAttributes</code> created. Use one of the
 creation methods on <a href="../../../../org/apache/geode/cache/EvictionAttributes.html" title="class in org.apache.geode.cache"><code>EvictionAttributes</code></a> e.g.
 <a href="../../../../org/apache/geode/cache/EvictionAttributes.html#createLRUHeapAttributes--"><code>EvictionAttributes.createLRUHeapAttributes()</code></a> to create the desired instance for this
 <code>AttributesFactory</code></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>evictAttrs</code> - Explains how and when eviction occurs in the Region.</dd>
</dl>
</li>
</ul>
<a name="setMirrorType-org.apache.geode.cache.MirrorType-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMirrorType</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setMirrorType(<a href="../../../../org/apache/geode/cache/MirrorType.html" title="class in org.apache.geode.cache">MirrorType</a>&nbsp;mirrorType)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDataPolicy-org.apache.geode.cache.DataPolicy-"><code>setDataPolicy(org.apache.geode.cache.DataPolicy)</code></a> instead.</span></div>
<div class="block">Sets the mirror type for the next <code>RegionAttributes</code> created.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>mirrorType</code> - The type of mirroring to use for the region</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if mirrorType is null</dd>
</dl>
</li>
</ul>
<a name="setDataPolicy-org.apache.geode.cache.DataPolicy-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDataPolicy</h4>
<pre>public&nbsp;void&nbsp;setDataPolicy(<a href="../../../../org/apache/geode/cache/DataPolicy.html" title="class in org.apache.geode.cache">DataPolicy</a>&nbsp;dataPolicy)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the data policy for the next <code>RegionAttributes</code> created. Default data policy is
 'Normal'. Please refer gemfire documentation for more details on this.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>dataPolicy</code> - The data policy to use for the region</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if dataPolicy is null</dd>
</dl>
</li>
</ul>
<a name="setKeyConstraint-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setKeyConstraint</h4>
<pre>public&nbsp;void&nbsp;setKeyConstraint(<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>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>&gt;&nbsp;keyConstraint)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the key constraint for the next <code>RegionAttributes</code> created. Keys in the region will
 be constrained to this class (or subclass). Any attempt to store a key of an incompatible type
 in the region will cause a <code>ClassCastException</code> to be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyConstraint</code> - The Class to constrain the keys to, or null if no constraint</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if <code>keyConstraint</code> is a class denoting a primitive type</dd>
</dl>
</li>
</ul>
<a name="setValueConstraint-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setValueConstraint</h4>
<pre>public&nbsp;void&nbsp;setValueConstraint(<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>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;valueConstraint)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the value constraint for the next <code>RegionAttributes</code> created. Values in the region
 will be constrained to this class (or subclass). Any attempt to store a value of an
 incompatible type in the region will cause a <code>ClassCastException</code> to be thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>valueConstraint</code> - The Class to constrain the values to, or null if no constraint</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if <code>valueConstraint</code> is a class denoting a primitive
         type</dd>
</dl>
</li>
</ul>
<a name="setInitialCapacity-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setInitialCapacity</h4>
<pre>public&nbsp;void&nbsp;setInitialCapacity(int&nbsp;initialCapacity)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the entry initial capacity for the next <code>RegionAttributes</code> created. This value is
 used in initializing the map that holds the entries. Default is 16.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>initialCapacity</code> - the initial capacity of the entry map</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if initialCapacity is negative.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util"><code>HashMap</code></a></dd>
</dl>
</li>
</ul>
<a name="setLoadFactor-float-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setLoadFactor</h4>
<pre>public&nbsp;void&nbsp;setLoadFactor(float&nbsp;loadFactor)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the entry load factor for the next <code>RegionAttributes</code> created. This value is used in
 initializing the map that holds the entries. Default is 0.75.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>loadFactor</code> - the load factor of the entry map</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if loadFactor is nonpositive</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util"><code>HashMap</code></a></dd>
</dl>
</li>
</ul>
<a name="setConcurrencyLevel-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setConcurrencyLevel</h4>
<pre>public&nbsp;void&nbsp;setConcurrencyLevel(int&nbsp;concurrencyLevel)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the concurrency level of the next <code>RegionAttributes</code> created. This value is used in
 initializing the map that holds the entries. Default is 16.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>concurrencyLevel</code> - the concurrency level of the entry map</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if concurrencyLevel is nonpositive</dd>
</dl>
</li>
</ul>
<a name="setConcurrencyChecksEnabled-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setConcurrencyChecksEnabled</h4>
<pre>public&nbsp;void&nbsp;setConcurrencyChecksEnabled(boolean&nbsp;concurrencyChecksEnabled)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Enables or disabled concurrent modification checks. Concurrency checks are enabled by default.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>concurrencyChecksEnabled</code> - whether to perform concurrency checks on operations</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 7.0</dd>
</dl>
</li>
</ul>
<a name="setPersistBackup-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setPersistBackup</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setPersistBackup(boolean&nbsp;persistBackup)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/DataPolicy.html#PERSISTENT_REPLICATE"><code>DataPolicy.PERSISTENT_REPLICATE</code></a> instead</span></div>
<div class="block">Sets whether or not a persistent backup should be made of the region.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 3.2</dd>
</dl>
</li>
</ul>
<a name="setEarlyAck-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEarlyAck</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setEarlyAck(boolean&nbsp;earlyAck)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">This setting no longer has any effect.</span></div>
<div class="block">Sets whether or not acks are sent after an operation is processed.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 4.1</dd>
</dl>
</li>
</ul>
<a name="setPublisher-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setPublisher</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setPublisher(boolean&nbsp;v)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of 6.5</span></div>
<div class="block">Sets whether or not this region should be considered a publisher.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 4.2.3</dd>
</dl>
</li>
</ul>
<a name="setEnableAsyncConflation-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnableAsyncConflation</h4>
<pre>public&nbsp;void&nbsp;setEnableAsyncConflation(boolean&nbsp;enableAsyncConflation)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not conflation is enabled for sending messages to async peers. Default value is
 false.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 4.2.3</dd>
</dl>
</li>
</ul>
<a name="setEnableSubscriptionConflation-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnableSubscriptionConflation</h4>
<pre>public&nbsp;void&nbsp;setEnableSubscriptionConflation(boolean&nbsp;enableSubscriptionConflation)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not conflation is enabled for sending messages from a cache server to its
 clients. Default is false.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="addGatewaySenderId-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addGatewaySenderId</h4>
<pre>public&nbsp;void&nbsp;addGatewaySenderId(<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;gatewaySenderId)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">adds a gateway sender to the end of list of gateway senders on this factory</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if <code>gatewaySender</code> is null</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 7.0</dd>
</dl>
</li>
</ul>
<a name="addAsyncEventQueueId-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addAsyncEventQueueId</h4>
<pre>public&nbsp;void&nbsp;addAsyncEventQueueId(<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;asyncEventQueueId)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Adds a AsyncEventQueue to the end of list of async event queues on this factory</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if <code>gatewaySender</code> is null</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 7.0</dd>
</dl>
</li>
</ul>
<a name="setEnableBridgeConflation-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnableBridgeConflation</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setEnableBridgeConflation(boolean&nbsp;enableBridgeConflation)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of 5.7 use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-"><code>setEnableSubscriptionConflation(boolean)</code></a> instead.</span></div>
<div class="block">Sets whether or not conflation is enabled for sending messages from a cache server to its
 clients.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="setEnableConflation-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnableConflation</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setEnableConflation(boolean&nbsp;enableBridgeConflation)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setEnableSubscriptionConflation-boolean-"><code>setEnableSubscriptionConflation(boolean)</code></a></span></div>
<div class="block">Sets whether or not conflation is enabled for sending messages from a cache server to its
 clients.</div>
</li>
</ul>
<a name="setDiskWriteAttributes-org.apache.geode.cache.DiskWriteAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDiskWriteAttributes</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setDiskWriteAttributes(<a href="../../../../org/apache/geode/cache/DiskWriteAttributes.html" title="interface in org.apache.geode.cache">DiskWriteAttributes</a>&nbsp;attrs)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#setDiskStoreName-java.lang.String-"><code>setDiskStoreName(java.lang.String)</code></a> instead</span></div>
<div class="block">Returns whether or not disk writes are asynchronous.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 3.2</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../org/apache/geode/cache/Region.html#writeToDisk--"><code>Region.writeToDisk()</code></a></dd>
</dl>
</li>
</ul>
<a name="setDiskDirs-java.io.File:A-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDiskDirs</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setDiskDirs(<a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html?is-external=true" title="class or interface in java.io">File</a>[]&nbsp;diskDirs)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/DiskStoreFactory.html#setDiskDirs-java.io.File:A-"><code>DiskStoreFactory.setDiskDirs(java.io.File[])</code></a> instead</span></div>
<div class="block">Sets the directories with the default size of 10240 MB to which the region's data is written</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/geode/GemFireIOException.html" title="class in org.apache.geode">GemFireIOException</a></code> - if a directory does not exist</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 3.2</dd>
</dl>
</li>
</ul>
<a name="setDiskStoreName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDiskStoreName</h4>
<pre>public&nbsp;void&nbsp;setDiskStoreName(<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;name)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the DiskStore name attribute. This causes the region to use the <a href="../../../../org/apache/geode/cache/DiskStore.html" title="interface in org.apache.geode.cache"><code>DiskStore</code></a>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the diskstore</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 6.5</dd>
</dl>
</li>
</ul>
<a name="setDiskSynchronous-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDiskSynchronous</h4>
<pre>public&nbsp;void&nbsp;setDiskSynchronous(boolean&nbsp;isSynchronous)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether or not the writing to the disk is synchronous. Default is true.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>isSynchronous</code> - boolean if true indicates synchronous writes</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 6.5</dd>
</dl>
</li>
</ul>
<a name="setDiskDirsAndSizes-java.io.File:A-int:A-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDiskDirsAndSizes</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setDiskDirsAndSizes(<a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html?is-external=true" title="class or interface in java.io">File</a>[]&nbsp;diskDirs,
                                            int[]&nbsp;diskSizes)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of 6.5 use <a href="../../../../org/apache/geode/cache/DiskStoreFactory.html#setDiskDirsAndSizes-java.io.File:A-int:A-"><code>DiskStoreFactory.setDiskDirsAndSizes(java.io.File[], int[])</code></a> instead</span></div>
<div class="block">Sets the directories to which the region's data is written and also set their sizes in
 megabytes</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - if a dir does not exist or the length of the size array does
         not match to the length of the dir array or the given length is not a valid positive
         number</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.1</dd>
</dl>
</li>
</ul>
<a name="setPartitionAttributes-org.apache.geode.cache.PartitionAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setPartitionAttributes</h4>
<pre>public&nbsp;void&nbsp;setPartitionAttributes(<a href="../../../../org/apache/geode/cache/PartitionAttributes.html" title="interface in org.apache.geode.cache">PartitionAttributes</a>&nbsp;partition)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the <code>PartitionAttributes</code> that describe how the region is partitioned among members
 of the distributed system. This also establishes a data policy of <a href="../../../../org/apache/geode/cache/DataPolicy.html#PARTITION"><code>PARTITION</code></a>, if the data policy has not already been set.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="setBucketRegion-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setBucketRegion</h4>
<pre>protected&nbsp;void&nbsp;setBucketRegion(boolean&nbsp;b)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
</li>
</ul>
<a name="setMembershipAttributes-org.apache.geode.cache.MembershipAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMembershipAttributes</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;void&nbsp;setMembershipAttributes(<a href="../../../../org/apache/geode/cache/MembershipAttributes.html" title="class in org.apache.geode.cache">MembershipAttributes</a>&nbsp;membership)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">this API is scheduled to be removed</span></div>
<div class="block">Sets the <code>MembershipAttributes</code> that describe the membership roles required for reliable
 access to the region.</div>
</li>
</ul>
<a name="setSubscriptionAttributes-org.apache.geode.cache.SubscriptionAttributes-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSubscriptionAttributes</h4>
<pre>public&nbsp;void&nbsp;setSubscriptionAttributes(<a href="../../../../org/apache/geode/cache/SubscriptionAttributes.html" title="class in org.apache.geode.cache">SubscriptionAttributes</a>&nbsp;subscription)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the <code>SubscriptionAttributes</code> that describe how the region will subscribe to other
 distributed cache instances of the region.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="setIndexMaintenanceSynchronous-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setIndexMaintenanceSynchronous</h4>
<pre>public&nbsp;void&nbsp;setIndexMaintenanceSynchronous(boolean&nbsp;synchronous)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Set how indexes on the region should be maintained. It will be either synchronous or
 asynchronous. Default is true.</div>
</li>
</ul>
<a name="setStatisticsEnabled-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setStatisticsEnabled</h4>
<pre>public&nbsp;void&nbsp;setStatisticsEnabled(boolean&nbsp;statisticsEnabled)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether statistics are enabled for this region and its entries. Default is false.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>statisticsEnabled</code> - whether statistics are enabled</dd>
</dl>
</li>
</ul>
<a name="setIgnoreJTA-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setIgnoreJTA</h4>
<pre>public&nbsp;void&nbsp;setIgnoreJTA(boolean&nbsp;flag)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the flag telling a region to ignore JTA transactions. Default is false.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="setLockGrantor-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setLockGrantor</h4>
<pre>public&nbsp;void&nbsp;setLockGrantor(boolean&nbsp;isLockGrantor)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether this region should become lock grantor. Default value is false.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>isLockGrantor</code> - whether this region should become lock grantor</dd>
</dl>
</li>
</ul>
<a name="setMulticastEnabled-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMulticastEnabled</h4>
<pre>public&nbsp;void&nbsp;setMulticastEnabled(boolean&nbsp;value)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets whether distributed operations on this region should attempt to use multicast. Multicast
 must also be enabled in the cache's DistributedSystem (see <a
 href=../distributed/DistributedSystem.html#mcast-port">"mcast-port"</a>). Default is false.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../org/apache/geode/cache/RegionAttributes.html#getMulticastEnabled--"><code>RegionAttributes.getMulticastEnabled()</code></a></dd>
</dl>
</li>
</ul>
<a name="setCloningEnabled-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCloningEnabled</h4>
<pre>public&nbsp;void&nbsp;setCloningEnabled(boolean&nbsp;cloningEnable)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets cloning on region. Default is false. Note: off-heap regions always behave as if cloning is
 enabled.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 6.1</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../org/apache/geode/cache/RegionAttributes.html#getCloningEnabled--"><code>RegionAttributes.getCloningEnabled()</code></a></dd>
</dl>
</li>
</ul>
<a name="setPoolName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setPoolName</h4>
<pre>public&nbsp;void&nbsp;setPoolName(<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;name)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets the pool name attribute. This causes regions that use these attributes to be a client
 region which communicates with the servers that the connection pool communicates with.
 <p>
 If this attribute is set to <code>null</code> or <code>""</code> then the connection pool is disabled
 causing regions that use these attributes to be communicate with peers instead of servers.
 <p>
 The named connection pool must exist on the cache at the time these attributes are used to
 create a region. See <a href="../../../../org/apache/geode/cache/client/PoolManager.html#createFactory--"><code>PoolManager.createFactory()</code></a> for how to create a connection pool.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - the name of the connection pool to use; if <code>null</code> or <code>""</code> then the
        connection pool is disabled for regions using these attributes.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.7</dd>
</dl>
</li>
</ul>
<a name="setCompressor-org.apache.geode.compression.Compressor-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCompressor</h4>
<pre>public&nbsp;void&nbsp;setCompressor(<a href="../../../../org/apache/geode/compression/Compressor.html" title="interface in org.apache.geode.compression">Compressor</a>&nbsp;compressor)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Sets this region's compressor for compressing entry values.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>compressor</code> - a compressor.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 8.0</dd>
</dl>
</li>
</ul>
<a name="setOffHeap-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setOffHeap</h4>
<pre>public&nbsp;void&nbsp;setOffHeap(boolean&nbsp;offHeap)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Enables this region's usage of off-heap memory if true.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>offHeap</code> - boolean flag to enable off-heap memory</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Geode 1.0</dd>
</dl>
</li>
</ul>
<a name="createRegionAttributes--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createRegionAttributes</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public&nbsp;<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;createRegionAttributes()</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">as of GemFire 5.0, use <a href="../../../../org/apache/geode/cache/AttributesFactory.html#create--"><code>create()</code></a> instead</span></div>
<div class="block">Creates a <code>RegionAttributes</code> with the current settings.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the newly created <code>RegionAttributes</code></dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang">IllegalStateException</a></code> - if the current settings violate the
         <a href="#compatibility">compatibility rules</a></dd>
</dl>
</li>
</ul>
<a name="create--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>create</h4>
<pre>public&nbsp;<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">K</a>,<a href="../../../../org/apache/geode/cache/AttributesFactory.html" title="type parameter in AttributesFactory">V</a>&gt;&nbsp;create()</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Creates a <code>RegionAttributes</code> with the current settings.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the newly created <code>RegionAttributes</code></dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang">IllegalStateException</a></code> - if the current settings violate the
         <a href="#compatibility">compatibility rules</a></dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 5.0</dd>
</dl>
</li>
</ul>
<a name="validateAttributes-org.apache.geode.cache.RegionAttributes-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>validateAttributes</h4>
<pre>public static&nbsp;void&nbsp;validateAttributes(<a href="../../../../org/apache/geode/cache/RegionAttributes.html" title="interface in org.apache.geode.cache">RegionAttributes</a>&lt;?,?&gt;&nbsp;attrs)</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block">Validates that the attributes are consistent with each other. The following rules are checked
 and enforced:
 <ul>
 <li>If the data policy <a href="../../../../org/apache/geode/cache/DataPolicy.html#withReplication--"><code>uses replication</code></a> and the scope is
 <a href="../../../../org/apache/geode/cache/Scope.html#isDistributed--"><code>distributed</code></a> then the following are incompatible:
 <ul>
 <li>ExpirationAction.LOCAL_INVALIDATE on the region</li<li>ExpirationAction.LOCAL_DESTROY on
 the entries</li>
 <li>ExpirationAction.LOCAL_INVALIDATE on the entries</li>
 <li>An LRU with local destroy eviction action</li>
 </ul>
 </li>
 <li>Region or entry expiration is incompatible with disabled statistics on the region</li>
 <li>Entry expiration is incompatible with the <a href="../../../../org/apache/geode/cache/DataPolicy.html#EMPTY"><code>DataPolicy.EMPTY</code></a> data policy</li>
 <li><a href="../../../../org/apache/geode/cache/EvictionAttributes.html" title="class in org.apache.geode.cache"><code>Eviction</code></a> is incompatible with the <a href="../../../../org/apache/geode/cache/DataPolicy.html#EMPTY"><code>DataPolicy.EMPTY</code></a> data
 policy</li>
 </ul></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>attrs</code> - the attributes to validate</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html?is-external=true" title="class or interface in java.lang">IllegalStateException</a></code> - if the attributes are not consistent with each other.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>GemFire 3.5</dd>
</dl>
</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>
<div class="subNav">
<ul class="navList">
<li>Prev&nbsp;Class</li>
<li><a href="../../../../org/apache/geode/cache/AttributesMutator.html" title="interface in org.apache.geode.cache"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/geode/cache/AttributesFactory.html" target="_top">Frames</a></li>
<li><a href="AttributesFactory.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><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
