How to use

FragmentWriter

in

com.ociweb.pronghorn.pipe

private int stopReSendingMessage(Pipe<MQTTClientToServerSchema> clientToSerer, int packetId) {
  ////////////////////////
  ///stop re-sending the message
  ///////////////////////
  Pipe.presumeRoomForWrite(clientToServerAck);
  FragmentWriter.writeI(clientToServerAck, MQTTClientToServerSchemaAck.MSG_STOPREPUBLISH_99, packetId);
  
  return packetId;
}

private void requestReplayOfPersistedCollection() {
  Pipe.presumeRoomForWrite(persistBlobStoreConsumer);
  FragmentWriter.write(persistBlobStoreConsumer, PersistedBlobStoreConsumerSchema.MSG_REQUESTREPLAY_6);
}

public void ackPublishedPos(int packetId) {	
  
  
  if (isPersistantSession) {
    //logger.trace("BBB must clear top level ack from drive {} ",packetId);
    
    Pipe.presumeRoomForWrite(persistBlobStoreConsumer);
    FragmentWriter.writeL(persistBlobStoreConsumer, PersistedBlobStoreConsumerSchema.MSG_RELEASE_7,
        packetId
        );
    
    //will clear locally upon ack
  } else {
    
    //logger.trace("BBB must clear top level ack form memory {} ",packetId);
    
    ackPublishedPosLocal(packetId);
  }
}

  FragmentWriter.write(clientToServerAck, MQTTClientToServerSchemaAck.MSG_BROKERACKNOWLEDGEDCONNECTION_98);
FragmentWriter.writeII(clientResponse,
      MQTTClientResponseSchema.MSG_CONNECTIONATTEMPT_5, 
      retCode,
      FragmentWriter.writeLI(clientToServerAck, MQTTClientToServerSchemaAck.MSG_PUBACK_4, mostRecentTime, serverSidePacketId);
      FragmentWriter.writeLI(serverToClient, MQTTClientToServerSchema.MSG_PUBREC_5, mostRecentTime, serverSidePacketId);
FragmentWriter.writeLI(clientToServerAck, 
    MQTTClientToServerSchemaAck.MSG_PUBREL_6,
    mostRecentTime, 
FragmentWriter.writeLI(clientToServerAck, 
     MQTTClientToServerSchemaAck.MSG_PUBCOMP_7, 
     mostRecentTime, 
FragmentWriter.writeI(clientResponse, 
        MQTTClientResponseSchema.MSG_SUBSCRIPTIONRESULT_4,
        maxQoS); 

 FragmentWriter.writeL(out, MQTTServerToClientSchema.MSG_PINGRESP_13, 
              arrivalTime);
FragmentWriter.writeLI(out, MQTTServerToClientSchema.MSG_UNSUBACK_11,
    arrivalTime,
    inputStream.readShort()
FragmentWriter.writeLII(out, MQTTServerToClientSchema.MSG_SUBACK_9,
    arrivalTime,
    inputStream.readShort(),
FragmentWriter.writeLI(out, MQTTServerToClientSchema.MSG_PUBCOMP_7,
    arrivalTime,
    inputStream.readShort()
FragmentWriter.writeLI(out, MQTTServerToClientSchema.MSG_PUBACK_4, 
           arrivalTime, 
           packetId40);
FragmentWriter.writeLI(out, MQTTServerToClientSchema.MSG_PUBREC_5,
            arrivalTime, 
            inputStream.readShort()
FragmentWriter.writeLI(out, MQTTServerToClientSchema.MSG_PUBREL_6,
    arrivalTime, 
    inputStream.readShort()
FragmentWriter.writeLII(out, MQTTServerToClientSchema.MSG_CONNACK_2, 
              arrivalTime,

  FragmentWriter.write(idRangeControl, MQTTIdRangeControllerSchema.MSG_CLEARALL_2);
  FragmentWriter.writeI(idRangeControl, MQTTIdRangeControllerSchema.MSG_IDRANGE_1, 
               IdGenStage.buildRange(fieldBlockId, fieldBlockId+1));
case PersistedBlobLoadConsumerSchema.MSG_FINISHREPLAY_9:				
  Pipe.presumeRoomForWrite(idRangeControl);
  FragmentWriter.write(idRangeControl, MQTTIdRangeControllerSchema.MSG_READY_3);
  isInReloadPersisted = false;
break;      		        

private void storePublishedPosPersisted(int blobPosition, int blobConsumed, byte[] blob, final int packetId) {
  Pipe.presumeRoomForWrite(persistBlobStoreProducer);
  FragmentWriter.writeLV(persistBlobStoreProducer, PersistedBlobStoreProducerSchema.MSG_BLOCK_1,
      packetId, //persist store supports long but we only have a packetId.
      blob, blobPosition, blobConsumed
      );
}

private void releaseSocketData(long connectionId, long netPosition) {
  Pipe.presumeRoomForWrite(ackReleaseForResponseParser);
  FragmentWriter.writeLL(ackReleaseForResponseParser, 
       ReleaseSchema.MSG_RELEASE_100, 
       connectionId,
       netPosition);
}

&& Pipe.hasRoomForWrite(releasePipe)) { 
FragmentWriter.writeI(releasePipe, TrafficReleaseSchema.MSG_RELEASE_20, goPendingOnPipeCount);

private void clearPersistedCollection() {
  Pipe.presumeRoomForWrite(persistBlobStoreConsumer);
  FragmentWriter.write(persistBlobStoreConsumer, PersistedBlobStoreConsumerSchema.MSG_CLEAR_12);
}

  if (0==i || 1==i) {
    Pipe.presumeRoomForWrite(loadProducerResponses);                               
  FragmentWriter.writeL(loadProducerResponses, PersistedBlobLoadProducerSchema.MSG_ACKWRITE_11, ackId);	
} else {
  Pipe.presumeRoomForWrite(loadReleaseResponses);
  FragmentWriter.writeL(loadReleaseResponses, PersistedBlobLoadReleaseSchema.MSG_ACKRELEASE_10, ackId);

private void clearAllStoredData() {
  int i = fileControl.length;
  clearInProgress = (byte)i;
  clearIdMap();
  isDirty = false;
  fileSizeWritten = 0;
  while (--i>=0) {
    //clear every file
    Pipe<SequentialCtlSchema> output = fileControl[i];
    Pipe.presumeRoomForWrite(output);
    FragmentWriter.write(output, SequentialCtlSchema.MSG_CLEAR_2);
  }
}

private void storeReleaseOfId(long fieldBlockId) {
   //keep in sync				     
   recordReleaseId(fieldBlockId);
      //write this id in case of power drop
   Pipe<RawDataSchema> out = fileOutput[fileOutput.length-1];
   int chunkSize = Pipe.addMsgIdx(out, RawDataSchema.MSG_CHUNKEDSTREAM_1);
   //logger.info("send out release data to be decrypted");
   DataOutputBlobWriter<RawDataSchema> chunkStr = Pipe.outputStream(out);
   DataOutputBlobWriter.openField(chunkStr);
   chunkStr.writePackedLong(fieldBlockId);
   DataOutputBlobWriter.closeLowLevelField(chunkStr);
      Pipe.confirmLowLevelWrite(out, chunkSize);
   Pipe.publishWrites(out);
   Pipe<SequentialCtlSchema> output = fileControl[fileControl.length-1];
      Pipe.presumeRoomForWrite(output);
   FragmentWriter.writeL(output, SequentialCtlSchema.MSG_IDTOSAVE_4, fieldBlockId);

   requestsInFlight++;
        }

@Override 
public void startup() {
  
  assert(fileControl.length == 3);
  int i = fileControl.length-1; //skip the ack index file
  this.waitCount = i;
  assert(waitCount==2) : "only 2 is supported";
  while (--i>=0) {
    Pipe<SequentialCtlSchema> output = fileControl[i];
    Pipe.presumeRoomForWrite(output);
    
    FragmentWriter.write(output, SequentialCtlSchema.MSG_METAREQUEST_3);
    
  }
  
  //will grow as needed
  mapSet = new LongHashSet(15);
  
}

FragmentWriter.writeL(control, SequentialCtlSchema.MSG_IDTOSAVE_4, blockId);

FragmentWriter.write(output2, SequentialCtlSchema.MSG_CLEAR_2);
  FragmentWriter.write(output1, SequentialCtlSchema.MSG_REPLAY_1);
FragmentWriter.write(output, SequentialCtlSchema.MSG_REPLAY_1);

  FragmentWriter.write(output1, SequentialCtlSchema.MSG_REPLAY_1);
FragmentWriter.write(output, SequentialCtlSchema.MSG_REPLAY_1);
FragmentWriter.write(loadConsumerResponses, PersistedBlobLoadConsumerSchema.MSG_BEGINREPLAY_8);

    FragmentWriter.write(loadConsumerResponses, PersistedBlobLoadConsumerSchema.MSG_FINISHREPLAY_9);
case -1:		        	
  Pipe.presumeRoomForWrite(loadConsumerResponses);
  FragmentWriter.write(loadConsumerResponses, PersistedBlobLoadConsumerSchema.MSG_FINISHREPLAY_9);

FragmentWriter.write(idRangeControl, MQTTIdRangeControllerSchema.MSG_READY_3);