Kernels.h

Go to the documentation of this file.

#ifndef Kernels_h
#define Kernels_h

#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