Kernels.h

#ifndef Kernels_h
#define Kernels_h
 
/* SPDX-License-Identifier: CC0-1.0 */                                                                 
 
#include <iostream>
#include <string>
#include <vector>
 
#include "Camera.h"
#include "Cube.h"
#include "CollectorMap.h"
#include "IException.h"
#include "Pvl.h"
 
namespace Isis {
 
class Kernels {
    public:
      Kernels();
      Kernels(const Kernels &kernels);
      Kernels(const QString &filename);
      Kernels(Cube &cube);
      Kernels(Pvl &pvl);
      virtual ~Kernels() { UnLoad(); }
 
      Kernels &operator=(const Kernels &kernels);
 
      int size() const { return (_kernels.size());  }
      int Missing() const;
 
      void Init(Pvl &pvl);
      bool Add(const QString &kfile);
 
      void Clear();
      int Discover();
 
      void Manage();
      void UnManage();
      bool IsManaged() const;
 
      void InitializeNaifKernelPool();
 
      int Load(const QString &ktype);
      int Load();
 
      int UnLoad(const QString &ktype);
      int UnLoad();
 
      int UpdateLoadStatus();
 
      int Merge(const Kernels &other);
 
      QStringList getKernelTypes() const;
      QStringList getKernelList(const QString &ktype = "") 
                                             const;
      QStringList getLoadedList(const QString &ktypes = "") 
                                             const;
      QStringList getMissingList() const;
 
      
      int CameraVersion() const { return (_camVersion); }
 
  private:
    struct KernelFile {          
      QString  pathname;
      QString  name;
      QString  fullpath;
      bool         exists; 
      QString  ktype; 
      mutable bool loaded; 
      bool         managed;
    };
 
    typedef std::vector<KernelFile> KernelList;
    KernelList _kernels;
    int        _camVersion;
 
    typedef std::vector<KernelFile *> KernelFileList;
    typedef CollectorMap<QString, KernelFileList> TypeList;
 
    bool Load(KernelFile &kfile);
    bool UnLoad(KernelFile &kfile);
 
    QStringList getTypes(const QString &ktypes) const;
    QString resolveType(const QString &kfile) const;
    QString resolveTypeByExt(const QString &kfile, 
                                 const QString &iktype = "UNKNOWN") const;
 
    bool IsNaifType(const QString &ktype) const;
    KernelFile examine(const QString &fname, const bool &manage = true) 
                       const;
    int UpdateManagedStatus();
    std::vector<KernelFile> findKernels(Pvl &pvl, const QString &kname,
                                       const bool &manage = true);
    KernelFile *findByName(const QString &kfile);
    TypeList categorizeByType() const;
      
    void addKernels(const KernelList &klist);
    QString getKernelType(const QString &kname) const; 
    void loadKernel(const QString &ktype = "");
    int getCameraVersion(Pvl &pvl) const;
 
};
 
}     // namespace Isis
#endif