How to use

getRegion

method

in

com.gemstone.gemfire.internal.cache.RegionQueue

public boolean done() {
 boolean done = numQueueEntries == queues
   .toArray(new RegionQueue[queues.size()])[0].getRegion().size();
 return done;
}

@Override
public Region getRegion() {
  return this.processors[0].getQueue().getRegion();
}

@Override
public Region getRegion() {
  return this.processors[0].getQueue().getRegion();
}

public static HashMap checkQueue_PR(String senderId){
 Set<GatewaySender> senders = cache.getGatewaySenders();
 GatewaySender sender = null;
 for(GatewaySender s : senders){
  if(s.getId().equals(senderId)){
   sender = s;
   break;
  }
 }
 
 RegionQueue parallelQueue = (RegionQueue)((ParallelGatewaySenderImpl)sender)
 .getQueues().toArray(new RegionQueue[1])[0];
 
 PartitionedRegion region = (PartitionedRegion)parallelQueue.getRegion();
 QueueListener listener = (QueueListener)region.getCacheListener();
 
 HashMap listenerAttrs = new HashMap();
 listenerAttrs.put("Create", listener.createList);
 listenerAttrs.put("Update", listener.updateList);
 listenerAttrs.put("Destroy", listener.destroyList);
 return listenerAttrs;
}

protected void destroyProcessor() {
 if (logger.isDebugEnabled()) {
  logger.debug("Destroying dispatcher");
 }
 try {
  try {
   if (this.queue.peek() != null) {
    logger.warn(LocalizedMessage.create(LocalizedStrings.GatewayImpl_DESTROYING_GATEWAYEVENTDISPATCHER_WITH_ACTIVELY_QUEUED_DATA));
   }
  } catch (InterruptedException e) {
   /*
    * ignore, 
    */
   // TODO if this won't be thrown, assert it.
  }
 } catch (CacheException ignore) {
  // just checking in case we should log a warning
 } finally {
  this.queue.getRegion().localDestroyRegion();
  if (logger.isDebugEnabled()) {
   logger.debug("Destroyed dispatcher");
  }
 }
}

public static HashMap checkQueue_BR(String senderId, int numBuckets){
 Set<GatewaySender> senders = cache.getGatewaySenders();
 GatewaySender sender = null;
 for(GatewaySender s : senders){
  if(s.getId().equals(senderId)){
   sender = s;
   break;
  }
 }
 RegionQueue parallelQueue = (RegionQueue)((ParallelGatewaySenderImpl)sender)
 .getQueues().toArray(new RegionQueue[1])[0];
 
 PartitionedRegion region = (PartitionedRegion)parallelQueue.getRegion();
 HashMap listenerAttrs = new HashMap();
 for (int i = 0; i < numBuckets; i++) {
  BucketRegion br = region.getBucketRegion(i);
  if (br != null) {
   QueueListener listener = (QueueListener)br.getCacheListener();
   if (listener != null) {
    listenerAttrs.put("Create"+i, listener.createList);
    listenerAttrs.put("Update"+i, listener.updateList);
    listenerAttrs.put("Destroy"+i, listener.destroyList);
   }
  }
 }
 return listenerAttrs;
}

 regions.add(processor.getQueue().getRegion());
 logger.info("Serial gateway sender " + sender.getId() + " uses region named " + processor.getQueue().getRegion().getFullPath());
} else if (processor instanceof ParallelGatewaySenderEventProcessor) {
 sb.append("Concurrent serial gateway sender " + sender.getId() + " uses " + queues.size() + " regions");
 for (RegionQueue queue : queues) {
  Region aRegion = queue.getRegion();
  regions.add(aRegion);
  sb.append(" " + aRegion.getFullPath());

public static void validateParallelSenderQueueBucketSize(final String senderId, final int bucketSize) {
 Set<GatewaySender> senders = cache.getGatewaySenders();
 GatewaySender sender = null;
 for (GatewaySender s : senders) {
  if (s.getId().equals(senderId)) {
   sender = s;
   break;
  }
 }
 RegionQueue regionQueue = ((ParallelGatewaySenderImpl)sender).getQueues().toArray(new RegionQueue[1])[0];
 Set<BucketRegion> buckets = ((PartitionedRegion)regionQueue.getRegion()).getDataStore().getAllLocalPrimaryBucketRegions();
 for (BucketRegion bucket : buckets) {
  assertEquals("Expected bucket entries for bucket " + bucket.getId() + " is different than actual.", bucketSize, bucket.keySet().size());
 }
}

 regions.add(processor.getQueue().getRegion());
 Log.getLogWriter().info("Serial gateway sender " + sender.getId() + " uses region named " + processor.getQueue().getRegion().getFullPath());
} else if (processor instanceof ParallelGatewaySenderEventProcessor) {
 sb.append("Concurrent serial gateway sender " + sender.getId() + " uses " + queues.size() + " regions");
 for (RegionQueue queue : queues) {
  Region aRegion = queue.getRegion();
  regions.add(aRegion);
  sb.append(" " + aRegion.getFullPath());

public static Integer getQueueContentSize(final String senderId) {
 Set<GatewaySender> senders = cache.getGatewaySenders();
 GatewaySender sender = null;
 for (GatewaySender s : senders) {
  if (s.getId().equals(senderId)) {
   sender = s;
   break;
  }
 }
 if (sender instanceof SerialGatewaySenderImpl) {
  final Set<RegionQueue> queues = ((SerialGatewaySenderImpl)sender)
    .getQueues();
  int size = 0;
  for (RegionQueue q : queues) {
   size += q.size();
  }
  return size;
 } else if (sender instanceof ParallelGatewaySenderImpl) {
  RegionQueue regionQueue = null;
  regionQueue = ((ParallelGatewaySenderImpl)sender).getQueues().toArray(
    new RegionQueue[1])[0];
  return regionQueue.getRegion().size();
 }
 return 0;
}

private void addCacheListenerOnQueueBucketRegion(String senderId, int numBuckets){
 Set<GatewaySender> senders = cache.getGatewaySenders();
 GatewaySender sender = null;
 for(GatewaySender s : senders){
  if(s.getId().equals(senderId)){
   sender = s;
   break;
  }
 }
 RegionQueue parallelQueue = (RegionQueue)((ParallelGatewaySenderImpl)sender)
 .getQueues().toArray(new RegionQueue[1])[0];
 
 PartitionedRegion region = (PartitionedRegion)parallelQueue.getRegion();
 for (int i = 0; i < numBuckets; i++) {
  BucketRegion br = region.getBucketRegion(i);
  if (br != null) {
   AttributesMutator mutator = br.getAttributesMutator();
   CacheListener listener = new QueueListener();
   mutator.addCacheListener(listener);
  }
 }
}

public static void checkAsyncEventQueueSize(String asyncQueueId, int numQueueEntries) {
 AsyncEventQueue theAsyncEventQueue = null;
 
 Set<AsyncEventQueue> asyncEventChannels = cache.getAsyncEventQueues();
 for (AsyncEventQueue asyncChannel : asyncEventChannels) {
  if (asyncQueueId.equals(asyncChannel.getId())) {
   theAsyncEventQueue = asyncChannel;
  }
 }
 
 GatewaySender sender = ((AsyncEventQueueImpl)theAsyncEventQueue).getSender();
 
 if (sender instanceof ParallelGatewaySenderImpl) {
  Set<RegionQueue> queues = ((ParallelGatewaySenderImpl)sender).getQueues();
  assertEquals(numQueueEntries,
    queues.toArray(new RegionQueue[queues.size()])[0].getRegion().size());
 } else {
  Set<RegionQueue> queues = ((SerialGatewaySenderImpl)sender).getQueues();
  int size = 0;
  for (RegionQueue q : queues) {
   size += q.size();
  }
  assertEquals(numQueueEntries, size);
 }
}

Set<BucketRegion> buckets = ((PartitionedRegion) regionQueue.getRegion())
  .getDataStore().getAllLocalPrimaryBucketRegions();
for (final BucketRegion bucket : buckets) {

 ((ParallelGatewaySenderImpl)sender).getQueues().toArray(new RegionQueue[1])[0].getRegion().getName())) {
fail("The shadowPR is exposed to the user");

if (this.queue.getRegion() != null) {
  this.queue.getRegion().localDestroyRegion();

 assertEquals(regionQueues.size(), 1);
 RegionQueue regionQueue = regionQueues.iterator().next();
 assertEquals(true, regionQueue.getRegion().getAttributes()
   .isDiskSynchronous());
} finally {

 RegionQueue regionQueue = regionQueues.iterator().next();
 assertEquals(false, regionQueue.getRegion().getAttributes()
   .isDiskSynchronous());
} finally {

 assertEquals(regionQueues.size(), 1);
 RegionQueue regionQueue = regionQueues.iterator().next();
 assertEquals(true, regionQueue.getRegion().getAttributes()
   .isDiskSynchronous());
} finally {

 assertEquals(regionQueues.size(), 1);
 RegionQueue regionQueue = regionQueues.iterator().next();
 assertEquals(false, regionQueue.getRegion().getAttributes()
   .isDiskSynchronous());
} finally {

  .getQueues().toArray()[0];
PartitionedRegion region = (PartitionedRegion) parallelQueue
  .getRegion();
for (int i = 0; i < region.getTotalNumberOfBuckets(); i++) {
 BucketRegion br = region.getBucketRegion(i);