CubeIoHandler.h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#ifndef CubeIoHandler_h
#define CubeIoHandler_h
 
#include <QRunnable>
#include <QThreadPool>
 
#include "Constants.h"
#include "IEndian.h"
#include "ImageIoHandler.h"
#include "PixelType.h"
 
class QFile;
class QMutex;
class QElapsedTimer;
template <typename A> class QList;
template <typename A, typename B> class QMap;
 
namespace Isis {
  class Buffer;
  class CubeCachingAlgorithm;
  class EndianSwapper;
  class Pvl;
  class RawCubeChunk;

  class CubeIoHandler : public ImageIoHandler {
    public:
      CubeIoHandler(QFile * dataFile, const QList<int> *virtualBandList,
          const Pvl &label, bool alreadyOnDisk);
      virtual ~CubeIoHandler();
 
      virtual void read(Buffer &bufferToFill) const;
      virtual void write(const Buffer &bufferToWrite);
 
      virtual void addCachingAlgorithm(CubeCachingAlgorithm *algorithm);
      virtual void clearCache(bool blockForWriteCache = true) const;
      virtual BigInt getDataSize() const;
      virtual void updateLabels(Pvl &labels) = 0;
 
      int bandCount() const;
      int getBandCountInChunk() const;
      BigInt getBytesPerChunk() const;
      int getChunkCountInBandDimension() const;
      int getChunkCountInLineDimension() const;
      int getChunkCountInSampleDimension() const;
      int getChunkIndex(const RawCubeChunk &)  const;
      BigInt getDataStartByte() const;
      int lineCount() const;
      int getLineCountInChunk() const;
      PixelType pixelType() const;
      int sampleCount() const;
      int getSampleCountInChunk() const;
 
    protected:
      QFile * getDataFile();
 
      void setChunkSizes(int numSamples, int numLines, int numBands);

      virtual void readRaw(RawCubeChunk &chunkToFill) = 0;

      virtual void writeRaw(const RawCubeChunk &chunkToWrite) = 0;
 
    private:
      class BufferToChunkWriter : public QRunnable {
        public:
          BufferToChunkWriter(CubeIoHandler * ioHandler,
                              QList<Buffer *> buffersToWrite);
          ~BufferToChunkWriter();
 
          void run();
 
        private:
          BufferToChunkWriter(const BufferToChunkWriter & other);
          BufferToChunkWriter & operator=(const BufferToChunkWriter & rhs);
 
        private:
          CubeIoHandler * m_ioHandler;
          QList<Buffer * > * m_buffersToWrite;
          QElapsedTimer *m_timer;
      };
 

      CubeIoHandler(const CubeIoHandler &other);

      CubeIoHandler &operator=(const CubeIoHandler &other);
 
      void blockUntilThreadPoolEmpty() const;
 
      static bool bufferLessThan(Buffer * const &lhs, Buffer * const &rhs);
 
      QPair< QList<RawCubeChunk *>, QList<int> > findCubeChunks(int startSample, int numSamples,
                                                                int startLine, int numLines,
                                                                int startBand, int numBands) const;
 
      void findIntersection(const RawCubeChunk &cube1,
          const Buffer &cube2, int &startX, int &startY, int &startZ,
          int &endX, int &endY, int &endZ) const;
 
      void flushWriteCache(bool force = false) const;
 
      void freeChunk(RawCubeChunk *chunkToFree) const;
 
      RawCubeChunk *getChunk(int chunkIndex, bool allocateIfNecessary) const;
 
      int getChunkCount() const;
 
      void getChunkPlacement(int chunkIndex,
        int &startSample, int &startLine, int &startBand,
        int &endSample, int &endLine, int &endBand) const;
 
      RawCubeChunk *getNullChunk(int chunkIndex) const;
 
      void minimizeCache(const QList<RawCubeChunk *> &justUsed,
                         const Buffer &justRequested) const;
 
      void synchronousWrite(const Buffer &bufferToWrite);
 
      void writeIntoDouble(const RawCubeChunk &chunk, Buffer &output, int startIndex) const;
 
      void writeIntoRaw(const Buffer &buffer, RawCubeChunk &output, int index) const;
 
      void writeNullDataToDisk() const;
 
    private:
      QFile * m_dataFile;

      BigInt m_startByte;

      PixelType m_pixelType;

      double m_base;

      double m_multiplier;

      ByteOrder m_byteOrder;

      EndianSwapper * m_byteSwapper;

      int m_numSamples;

      int m_numLines;

      int m_numBands;

      QList<CubeCachingAlgorithm *> * m_cachingAlgorithms;

      mutable QMap<int, RawCubeChunk *> * m_rawData;

      mutable QMap<int, bool> * m_dataIsOnDiskMap;
 

      int m_samplesInChunk;

      int m_linesInChunk;

      int m_bandsInChunk;

      mutable QList<RawCubeChunk *> *m_lastProcessByLineChunks;

      mutable QByteArray *m_nullChunkData;

      QPair< QMutex *, QList<Buffer *> > *m_writeCache;

      mutable QThreadPool *m_ioThreadPool;

      mutable bool m_lastOperationWasWrite;
      bool m_useOptimizedCubeWrite;

      mutable volatile int m_idealFlushSize;

      mutable int m_consecutiveOverflowCount;
  };
}
 
#endif