CubeIoHandler.h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#ifndef CubeIoHandler_h
#define CubeIoHandler_h
 
#include <QRunnable>
#include <QThreadPool>
 
#include "Constants.h"
#include "Endian.h"
#include "PixelType.h"
 
class QFile;
class QMutex;
class QElapsedTimer;
template <typename A> class QList;
template <typename A, typename B> class QMap;
template <typename A, typename B> struct QPair;
 
namespace Isis {
  class Buffer;
  class CubeCachingAlgorithm;
  class EndianSwapper;
  class Pvl;
  class RawCubeChunk;
 
  class CubeIoHandler {
    public:
      CubeIoHandler(QFile * dataFile, const QList<int> *virtualBandList,
          const Pvl &label, bool alreadyOnDisk);
      virtual ~CubeIoHandler();
 
      void read(Buffer &bufferToFill) const;
      void write(const Buffer &bufferToWrite);
 
      void addCachingAlgorithm(CubeCachingAlgorithm *algorithm);
      void clearCache(bool blockForWriteCache = true) const;
      BigInt getDataSize() const;
      void setVirtualBands(const QList<int> *virtualBandList);
      virtual void updateLabels(Pvl &labels) = 0;
 
      QMutex *dataFileMutex();
 
    protected:
      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;
      QFile * getDataFile();
      int lineCount() const;
      int getLineCountInChunk() const;
      PixelType pixelType() const;
      int sampleCount() const;
      int getSampleCountInChunk() const;
 
      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;
 
      QList<int> * m_virtualBands;
 
      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;
 
      QMutex *m_writeThreadMutex;
 
      mutable volatile int m_idealFlushSize;
 
      mutable int m_consecutiveOverflowCount;
  };
}
 
#endif