Module.h

#ifndef Module_h
#define Module_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
 
#include "HiCalTypes.h"
#include "HiCalUtil.h"
#include "HiCalConf.h"
#include "LoadCSV.h"
#include "PvlKeyword.h"
#include "PvlGroup.h"
#include "IException.h"
 
namespace Isis {
 
  class PvlGroup;
 
  class Module {
    public:
      friend std::ostream &operator<<(std::ostream &o, const Module &c) {
        c.printOn(o);
        return (o);
      }
 
    public:
      //  Constructors and Destructor
      Module() : _name("Module"), _csvFile(""), _data(), _history(),
                  _fmtWidth(DefaultWidth),  _fmtPrecision(DefaultPrecision) { }
      Module(const QString &name) : _name(name), _csvFile(""), _data(),
                 _history(),_fmtWidth(DefaultWidth),
                 _fmtPrecision(DefaultPrecision) { }
      Module(const QString &name, const HiHistory &history) :
                _name(name), _csvFile(""), _data(), _history(history),
                _fmtWidth(DefaultWidth),  _fmtPrecision(DefaultPrecision) { }
      Module(const QString &name, const Module &c) : _name(name),
                _csvFile(c._csvFile), _data(c._data), _history(c._history),
                _fmtWidth(c._fmtWidth),_fmtPrecision(c._fmtPrecision) { }
      Module(const Module &c) : _name(c._name), _csvFile(c._csvFile),
                                      _data(c._data), _history(c._history),
                                      _fmtWidth(c._fmtWidth),
                                      _fmtPrecision(c._fmtPrecision) { }
 
 
      virtual ~Module() { }
 
      inline QString name() const { return (_name); }
      inline QString getcsvFile() const { return (_csvFile); }
      inline int size() const { return (_data.dim()); }
 
      virtual void Process(const Module &c) {
        Process(c.ref());
      }
 
      virtual void Process(const HiVector &v) {
        _data = v;
        return;
      }
 
      HiVector loadCsv(const QString &csvBase, const HiCalConf &conf,
                       const DbProfile &prof, const int &elements = 0)  {
        LoadCSV csv(csvBase, conf, prof);
        _csvFile = csv.filename();
        if (elements != 0) csv.validateSize(elements, true);
        csv.History(_history);
        return (csv.getVector());
      }
 
      const HiVector &ref() const { return (_data); }
      inline double operator()(int index) const { return (_data[index]);}
 
      const HiHistory &History() const { return (_history); }
 
      virtual void record(PvlGroup &pvl,
                          const QString keyname = "ModuleHistory")
                          const {
        pvl += _history.makekey(keyname);
        return;
      }
 
      void Dump(const QString &fname) const {
        FileName dumpc(fname);
        QString dumpcFile = dumpc.expanded();
        std::ofstream ofile(dumpcFile.toLatin1().data(), std::ios::out);
        if (!ofile) {
          QString mess = "Unable to open/create module dump file " +
                             dumpc.expanded();
          throw IException(IException::User, mess, _FILEINFO_);
        }
        ofile << *this;
        ofile.close();
        return;
      }
 
 
    protected:
      enum { DefaultWidth = 10, DefaultPrecision = 6};
 
      QString   _name;         
      QString   _csvFile;      
      HiVector      _data;         
      HiHistory     _history;      
      int           _fmtWidth;     
      int           _fmtPrecision; 
 
 
      inline QString formatDbl(const double &value) const {
        std::ostringstream ostr;
        if (IsSpecial(value)) {
          ostr << std::setw(_fmtWidth) << PixelToString(value);
          return (QString(ostr.str().c_str()));
        }
        else {
        // Its not special so format to callers specs
          ostr << std::setw(_fmtWidth) << std::setprecision(_fmtPrecision) << value;
          return (QString(ostr.str().c_str()));
        }
      }
 
      virtual void printOn(std::ostream &o) const {
        o << "#  History = " << _history << std::endl;
        o << "#  Count =   " << _data.dim() << std::endl;
        for (int i = 0 ; i < _data.dim() ; i++) {
          o << formatDbl(_data[i]) << std::endl;
        }
        return;
      }
 
  };
 
}     // namespace Isis
#endif