How to use

RegionQueue

in

com.gemstone.gemfire.internal.cache

public boolean done() {
 size = 0;
 for (RegionQueue q : queues) {
  size += q.size();
 }
 if (size == regionSize) {
  return true;
 }
 return false;
}

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

@Override
public void addCacheListener(CacheListener listener) {
  this.processors[0].getQueue().addCacheListener(listener);    
}

public void closeProcessor() {
 if (logger.isDebugEnabled()) {
  logger.debug("Closing dispatcher");
 }
 try {
  if (this.sender.isPrimary() && this.queue.size() > 0) {
   logger.warn(LocalizedMessage.create(LocalizedStrings.GatewayImpl_DESTROYING_GATEWAYEVENTDISPATCHER_WITH_ACTIVELY_QUEUED_DATA));
  }
 } catch (RegionDestroyedException ignore) {
 } catch (CancelException ignore) {
 } catch (CacheException ignore) {
  // just checking in case we should log a warning
 } finally {
  this.queue.close();
  if (logger.isDebugEnabled()) {
   logger.debug("Closed dispatcher");
  }
 }
}

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");
  }
 }
}

this.queue.removeCacheListener();
this.unprocessedTokens = null;
  Iterator it = this.queue.getRegion().values().iterator();
  while (it.hasNext() && !stopped()) {
   Object o = it.next();
  new Object[] {getSender(), Integer.valueOf(this.queue.size())}));
Iterator it = this.queue.getRegion().values().iterator();
while (it.hasNext() && !stopped()) {
 Object o = it.next();

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;
}

RegionQueue regionqueue = createHARegionQueue("testing");
for (int i = 0; i < 10; ++i) {
 regionqueue.put(new ConflatableObject("key" + (i + 1), "value",
   new EventID(new byte[] { 1 }, 1, i + 1), true, "testing"));

  .getQueues();
for (RegionQueue rq : sqSet) {
 rq.addCacheListener((CacheListener) queueListenerInstance);
  .getQueues().toArray()[0];
PartitionedRegion region = (PartitionedRegion) parallelQueue
  .getRegion();
for (int i = 0; i < region.getTotalNumberOfBuckets(); i++) {
 BucketRegion br = region.getBucketRegion(i);

  "testing");
regionqueue.put(cf1);
synchronized (this) {
 if (!expiryCalled) {
 Object o = regionqueue.take();
 assertNull(o);

protected void eventQueueRemove() throws CacheException,
  InterruptedException {
 this.queue.remove();
}

protected void closeProcessor()
{
 if (getLogger().fineEnabled()) {
  getLogger().fine("Closing dispatcher");
 }
 try {
  try {
   if (this._eventQueue.peek() != null) {
    getLogger()
      .warning(LocalizedStrings.GatewayImpl_DESTROYING_GATEWAYEVENTDISPATCHER_WITH_ACTIVELY_QUEUED_DATA);
   }
  }
  catch (InterruptedException e) {
   /*
    * ignore, this will never be thrown by
    * SingleWriteSingleReadRegionQueue
    */
   // TODO if this won't be thrown, assert it.
  }
 }
 catch (CacheException ignore) {
  // just checking in case we should log a warning
 }
 finally {
  this._eventQueue.close();
  if (getLogger().fineEnabled()) {
   getLogger().fine("Closed dispatcher");
  }
 }
}

 events = this.queue.peek(batchSize, batchTimeInterval);
} catch (InterruptedException e) {
 interrupted = true;

@Override
public void removeCacheListener() {
 this.queue.removeCacheListener();
}

protected Object eventQueueTake() throws CacheException, InterruptedException {
 return this._eventQueue.take();
}

this.queue.removeCacheListener();
this.unprocessedTokens = null;
  Iterator it = this.queue.getRegion().values().iterator();
  while (it.hasNext() && !stopped()) {
   Object o = it.next();
  new Object[] {getSender(), Integer.valueOf(this.queue.size())});
Iterator it = this.queue.getRegion().values().iterator();
while (it.hasNext() && !stopped()) {
 Object o = it.next();

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);
 }
}

public void closeProcessor() {
 if (getLogger().fineEnabled()) {
  getLogger().fine("Closing dispatcher");
 }
 try {
  if (this.sender.isPrimary() && this.queue.size() > 0) {
   getLogger()
   .warning(
     LocalizedStrings.GatewayImpl_DESTROYING_GATEWAYEVENTDISPATCHER_WITH_ACTIVELY_QUEUED_DATA);
  }
 } catch (RegionDestroyedException ignore) {
 } catch (CancelException ignore) {
 } catch (CacheException ignore) {
  // just checking in case we should log a warning
 } finally {
  this.queue.close();
  if (getLogger().fineEnabled()) {
   getLogger().fine("Closed dispatcher");
  }
 }
}

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

 this.queue.put(gatewayEvent);
} catch (InterruptedException e) {