CubeIoHandler.h

Go to the documentation of this file.

#ifndef CubeIoHandler_h
#define CubeIoHandler_h

#include <QRunnable>
#include <QThreadPool>

#include "Constants.h"
#include "Endian.h"
#include "PixelType.h"

class QFile;
class QMutex;
class QTime;
template <typename A> class QList;
template <typename A, typename B> class QMap;
template <typename A, typename B> class 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);

      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;
          QTime *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