BufferManager.h

#ifndef BufferManager_h
#define BufferManager_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Constants.h"
#include "PixelType.h"
#include "Buffer.h"
 
namespace Isis {
  class BufferManager : public Isis::Buffer {
 
    public:
      //  Constructors and Destructors
      BufferManager();
      BufferManager(int maxsamps, int maxlines, int maxbands,
                    int bufsamps, int buflines, int bufbands,
                    Isis::PixelType type, bool reverse = false);
      BufferManager(const BufferManager &other);
 
      ~BufferManager() {};
 
      // Traversal Methods
 
      bool operator++(int) {
        return (next());
      }
 
 
      BufferManager &operator+=(int i) {
        setpos(p_currentMap + i);
        return *this;
      }
 
      bool begin() {
        return (setpos(0));
      }
 
      bool next() {
        return (setpos(p_currentMap + 1));
      }
 
      bool end() const {
        return (p_currentMap >= p_nmaps);
      }
 
      bool setpos(BigInt map);
 
      void swap(BufferManager &other);
 
      BufferManager &operator=(const BufferManager &rhs);
 
    protected:
 
      //  Methods visable to deriving classes
 
      int MaxSamples() const {
        return (p_maxSamps);
      }
 
      int MaxLines() const {
        return (p_maxLines);
      }
 
      int MaxBands() const {
        return (p_maxBands);
      }
 
      BigInt MaxMaps() const {
        return (p_nmaps);
      }
 
      void SetIncrements(const int sinc, const int linc, const int binc);
      void SetOffsets(const int soff, const int loff, const int boff);
 
    private:
      int p_maxSamps;  
      int p_maxLines;  
      int p_maxBands;  
 
      int p_sinc;            
      int p_linc;            
      int p_binc;            
 
      int p_soff;            
      int p_loff;            
      int p_boff;            
 
      int p_currentSample;   
      int p_currentLine;     
      int p_currentBand;     
 
      BigInt p_nmaps;           
      BigInt p_currentMap;      
 
      bool p_reverse;
  };
};
 
#endif