ProcessByLine.h

#ifndef ProcessByLine_h
#define ProcessByLine_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "ProcessByBrick.h"
#include "Buffer.h"
namespace Isis {
  class Cube;
  class CubeAttributeInput;
 
  class ProcessByLine : public Isis::ProcessByBrick {
 
    public:
      ProcessByLine(): ProcessByBrick() {
        SetWrap(true);
      };
 
      using Isis::ProcessByBrick::SetInputCube; // make parents SetInputCube visable
      Isis::Cube *SetInputCube(const QString &parameter,
                               const int requirements = 0);
      Isis::Cube *SetInputCube(const QString &file,
                               Isis::CubeAttributeInput &att,
                               const int requirements = 0);
 
      void StartProcess(void funct(Isis::Buffer &inout));
      virtual void StartProcess(std::function<void(Isis::Buffer &in)> funct );
      void StartProcess(std::function<void(Buffer &in, Buffer &out)> funct);
 
      void StartProcess(void funct(Isis::Buffer &in, Isis::Buffer &out));
      void StartProcess(void
                        funct(std::vector<Isis::Buffer *> &in,
                              std::vector<Isis::Buffer *> &out));
 
      void SetBricks(IOCubes cn);
 
      template <typename Functor>
      void ProcessCubeInPlace(const Functor & funct, bool threaded = true) {
        VerifyCubes(InPlace);
        SetBricks(InPlace);
        ProcessByBrick::ProcessCubeInPlace(funct, threaded);
      }
 
 
      template <typename Functor>
      void ProcessCube(const Functor & funct, bool threaded = true) {
        VerifyCubes(InputOutput);
        SetBricks(InputOutput);
        ProcessByBrick::ProcessCube(funct, threaded);
      }
 
 
      template <typename Functor>
      void ProcessCubes(const Functor & funct, bool threaded = true) {
        VerifyCubes(InputOutputList);
        SetBricks(InputOutputList);
        ProcessByBrick::ProcessCubes(funct, threaded);
      }
  };
};
 
#endif