code: void process(Operation operation) throws DataCorruptionException {
          // Add entry to MemoryTransactionLog and ReadIndex/Cache. This callback is invoked from the OperationProcessor,
          // which always acks items in order of Sequence Number - so the entries should be ordered (but always check).
          if (operation instanceof StorageOperation) {
              addToReadIndex((StorageOperation) operation);
              if (operation instanceof StreamSegmentAppendOperation) {
                  // Transform a StreamSegmentAppendOperation into its corresponding Cached version.
                  try {
                      operation = new CachedStreamSegmentAppendOperation((StreamSegmentAppendOperation) operation);
                  } catch (Throwable ex) {
                      if (Exceptions.mustRethrow(ex)) {
                          throw ex;
                      } else {
                          throw new DataCorruptionException(String.format("Unable to create a CachedStreamSegmentAppendOperation from operation '%s'.", operation), ex);
                      }
                  }
              }
          }
  
          boolean added = this.inMemoryOperationLog.add(operation);
          if (!added) {
              // This is a pretty nasty one. It's safer to shut down the container than continue.
              // We either recorded the Operation correctly, but invoked this callback out of order, or we really
              // recorded the Operation in the wrong order (by sequence number). In either case, we will be inconsistent
              // while serving reads, so better stop now than later.
              throw new DataCorruptionException("About to have added a Log Operation to InMemoryOperationLog that was out of order.");
          }
      }
docs: Processes the given operation and applies it to the ReadIndex and InMemory OperationLog.
  
  @param operation The operation to process.
  @throws DataCorruptionException If a serious, non-recoverable, data corruption was detected, such as trying to
  append operations out of order.