How to use

ObjectPipe

in

com.ociweb.pronghorn.pipe

public ProcessQuery(int pipelineBits, HTTPResponseService service, PoolManager pm) {
  
  
  this.DBRestInFlight = new ObjectPipe<ResultObject>(pipelineBits, ResultObject.class,	ResultObject::new);
  this.service = service;
  this.pm = pm;
  
  
}

public T headObject() {
  assert(isHeadThread());
  if (count()<mask) {
    return objects[head.get()&mask];
  } else {
    return null;
  }
}

public T tailObject() {
  assert(isTailThread());
  if (count()>0) {
    return objects[tail.get()&mask];
  } else {
    return null;
  }
}

long seqCode = request.getSequenceCode();
if (DBUpdateInFlight.hasRoomFor(queries)) {		
        final ResultObject worldObject = DBUpdateInFlight.headObject();
        assert(null!=worldObject);
        DBUpdateInFlight.moveHeadForward(); //always move to ensure this can be read.

public boolean restFortuneRequest(HTTPRequestReader request) {
  final FortunesObject target = fortuneInFlight.headObject(); 
  if (null!=target) {
    target.setConnectionId(request.getConnectionId());
    fortuneInFlight.moveHeadForward(); //always move to ensure this can be read.  //TODO: remove and combined with above
    return true;
  } else {

private boolean consumeResultObjectDBRest(final ResultObject t) {
  boolean ok;
          
  ///////////////////////////////
  if (0 == t.getGroupSize()) {	
    ok = service.publishHTTPResponse(t.getConnectionId(), t.getSequenceId(), 200,
        HTTPContentTypeDefaults.JSON,
        w-> {
          Templates.singleTemplateDBRest.render(w, t);
          t.setStatus(-1);
          DBRestInFlight.moveTailForward();//only move forward when it is consumed.
          DBRestInFlight.publishTailPosition();
        });                    
  } else {
    //collect all the objects
    assert(isValidToAdd(t, collectorDBRest));
    collectorDBRest.add(t);                    
    DBRestInFlight.moveTailForward();
    if (collectorDBRest.size() == t.getGroupSize()) {
      //now ready to send, we have all the data						
      ok =publishMultiDBResponse(t.getConnectionId(), t.getSequenceId());
      
    } else {
      ok = true;//added to list
    }    
    //moved forward so we can read next but write logic will still be blocked by state not -1			 
    
  }
  return ok;
}

public void tickEvent() { 
  {
    ResultObject temp = DBUpdateInFlight.tailObject();
    while (isReadyDBUpdate(temp)) {			
      if (consumeResultObjectDBUpdate(temp)) {
        temp = DBUpdateInFlight.tailObject();
      } else {
        break;
      }
    }       
  }
    
}

public void moveTailForward() {
  assert(isTailThread());
  tail.incrementAndGet();        
}

public boolean hasRoomFor(int count) {
  return (this.count()+count)<=mask;
}

private boolean publishMultiResponseDBUpdate(long conId, long seqCode) {
  boolean result =  service.publishHTTPResponse(conId, seqCode, 200,
                    HTTPContentTypeDefaults.JSON,
                    w-> {
                      Templates.multiTemplate.render(w, collectorDBUpdate);
                      int c = collectorDBUpdate.size();
                      while (--c>=0) {
                        assert(collectorDBUpdate.get(c).getConnectionId() == conId);
                        assert(collectorDBUpdate.get(c).getSequenceId() == seqCode);					    						   
                        collectorDBUpdate.get(c).setStatus(-1);
                      }
                      collectorDBUpdate.clear();
                      DBUpdateInFlight.publishTailPosition();
                    });
  collectionPendingDBUpdate = !result;
  return result;
}

private boolean consumeResultObjectDBUpdate(final ResultObject t) {
  boolean ok;
  //collect all the objects
  collectorDBUpdate.add(t);
  DBUpdateInFlight.moveTailForward();//only move forward when it is consumed.
  if (collectorDBUpdate.size() == t.getGroupSize()) {
    //now ready to send, we have all the data						
    ok =publishMultiResponseDBUpdate(t.getConnectionId(), t.getSequenceId());
  } else {
    ok = true;//added to list
  }                
  
  return ok;
}

public boolean multiRestRequest(HTTPRequestReader request) { 
  final int queries;
  if (Struct.DB_MULTI_ROUTE_INT == request.getRouteAssoc() ) {		
    queries = Math.min(Math.max(1, (request.structured().readInt(Field.QUERIES))),500);		
  } else {
    queries = 1;
  }
  

  if (DBRestInFlight.hasRoomFor(queries)) {
    
    sendQueries(pm.pool(),queries,request.getConnectionId(),request.getSequenceCode());
                
    return true;
  } else {
    return false;
  }    
}

final ResultObject target = DBRestInFlight.headObject();
DBRestInFlight.moveHeadForward(); //always move to ensure this can be read.

fortuneInFlight.moveTailForward();//only move forward when it is consumed.
fortuneInFlight.publishTailPosition();
t.list().clear();
htmlFortuneBuffer.clear();

public void tickEvent() { 
  //for DBRest
  {
    ResultObject temp = DBRestInFlight.tailObject();
    while (isReadyDBRest(temp)) {			
      if (consumeResultObjectDBRest(temp)) {
        temp = DBRestInFlight.tailObject();
      } else {
        break;
      }
    }
  }
  
  
}

public void moveTailForward() {
  assert(isTailThread());
  tail.incrementAndGet();        
}

public boolean hasRoomFor(int count) {
  return (this.count()+count)<=mask;
}

private boolean publishMultiDBResponse(long conId, long seqCode) {
  final boolean result =  service.publishHTTPResponse(conId, seqCode, 200,
                    HTTPContentTypeDefaults.JSON,
                    w-> {
                      Templates.multiTemplateDBRest.render(w, collectorDBRest);
                                            int c = collectorDBRest.size();
                      assert(collectorDBRest.get(0).getGroupSize()==c);
                      while (--c >= 0) {
                        assert(collectorDBRest.get(0).getGroupSize()==collectorDBRest.size());
                        assert(collectorDBRest.get(c).getConnectionId() == conId) : c+" expected conId "+conId+" error: "+showCollection(collectorDBRest);
                        assert(collectorDBRest.get(c).getSequenceId() == seqCode) : c+" sequence error: "+showCollection(collectorDBRest);    						   
                        collectorDBRest.get(c).setStatus(-1);
                                             }
                      collectorDBRest.clear();                                               
                      DBRestInFlight.publishTailPosition();
                    });
  collectionPendingDBRest = !result;
  return result;
}

public void moveHeadForward() {
  assert(isHeadThread());
  assert(count()<mask);
  head.incrementAndGet();        
}

public boolean singleRestRequest(HTTPRequestReader request) { 
  final ResultObject target = DBRestInFlight.headObject();
  if (null!=target && -1==target.getStatus()) {
    target.setConnectionId(request.getConnectionId());
    DBRestInFlight.moveHeadForward(); //always move to ensure this can be read.
    return true;
  } else {