SourceDB.h

Go to the documentation of this file.

// SourceDB.h: Base class for a table holding sources and their parameters
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_SOURCEDB_H
#define LOFAR_PARMDB_SOURCEDB_H
 
#include "SourceData.h"
#include "PatchInfo.h"
#include "ParmDBMeta.h"
#include "ParmDB.h"
 
#include <filesystem>
 
namespace dp3 {
namespace parmdb {
 
class ParmMap;
 
 
class SourceDBRep {
 public:
  SourceDBRep(const ParmDBMeta& ptm, bool forceNew);
 
  virtual ~SourceDBRep();
 
  void link() { itsCount++; }
 
  int unlink() { return --itsCount; }
 
  virtual void lock(bool lockForWrite);
  virtual void unlock();
 
  ParmDB& getParmDB() { return itsParmDB; }
 
  virtual void checkDuplicates() = 0;
 
  virtual std::vector<std::string> findDuplicatePatches() = 0;
 
  virtual std::vector<std::string> findDuplicateSources() = 0;
 
  virtual bool patchExists(const std::string& patchName) = 0;
 
  virtual bool sourceExists(const std::string& sourceName) = 0;
 
  virtual unsigned int addPatch(const std::string& patchName, int catType,
                                double apparentBrightness, double ra,
                                double dec, bool check) = 0;
 
  virtual void updatePatch(unsigned int patchId, double apparentBrightness,
                           double ra, double dec) = 0;
 
  virtual void addSource(const SourceInfo& sourceInfo,
                         const std::string& patchName,
                         const ParmMap& defaultParameters, double ra,
                         double dec, bool check) = 0;
  virtual void addSource(const SourceData& source, bool check) = 0;
 
  virtual void addSource(const SourceInfo& sourceInfo,
                         const std::string& patchName, int catType,
                         double apparentBrightness,
                         const ParmMap& defaultParameters, double ra,
                         double dec, bool check) = 0;
 
  virtual std::vector<std::string> getPatches(int category,
                                              const std::string& pattern,
                                              double minBrightness,
                                              double maxBrightness) = 0;
 
  virtual std::vector<PatchInfo> getPatchInfo(int category,
                                              const std::string& pattern,
                                              double minBrightness,
                                              double maxBrightness) = 0;
 
  virtual std::vector<SourceInfo> getPatchSources(
      const std::string& patchName) = 0;
 
  virtual std::vector<SourceData> getPatchSourceData(
      const std::string& patchName) = 0;
 
  virtual SourceInfo getSource(const std::string& sourceName) = 0;
 
  virtual std::vector<SourceInfo> getSources(const std::string& pattern) = 0;
 
  virtual void deleteSources(const std::string& sourceNamePattern) = 0;
 
  virtual void clearTables() = 0;
 
  const ParmDBMeta& getParmDBMeta() const { return itsParmDB.getParmDBMeta(); }
 
  virtual void getNextSource(SourceData& src) = 0;
 
  virtual bool atEnd() = 0;
 
  virtual void rewind() = 0;
 
 private:
  int itsCount;
  ParmDB itsParmDB;
};
 
class SourceDBBase {
 public:
  virtual ~SourceDBBase() = default;
 
  virtual void addSource(const SourceInfo& source_info,
                         const std::string& patch_name, int cat_type,
                         double apparent_brightness,
                         const ParmMap& default_parameters, double ra,
                         double dec, bool check) = 0;
 
  virtual void addSource(const SourceInfo& source_info,
                         const std::string& patch_name,
                         const ParmMap& default_parameters, double ra,
                         double dec, bool check) = 0;
 
  virtual unsigned addPatch(const std::string& patch_name, int cat_type,
                            double apparent_brightness, double ra, double dec,
                            bool check) = 0;
 
  virtual void updatePatch(unsigned patch_id, double apparent_brightness,
                           double ra, double dec) = 0;
};
 
class SourceDB final : public SourceDBBase {
 public:
  explicit SourceDB(const ParmDBMeta& ptm, bool mustExist, bool forceNew);
 
  SourceDB(const SourceDB&);
 
  ~SourceDB() override;
 
  SourceDB& operator=(const SourceDB&);
 
  void lock(bool lockForWrite = true) { itsRep->lock(lockForWrite); }
  void unlock() { itsRep->unlock(); }
 
  ParmDB& getParmDB() { return itsRep->getParmDB(); }
 
  void checkDuplicates() const { itsRep->checkDuplicates(); }
 
  std::vector<std::string> findDuplicatePatches() const {
    return itsRep->findDuplicatePatches();
  }
 
  std::vector<std::string> findDuplicateSources() const {
    return itsRep->findDuplicateSources();
  }
 
  bool patchExists(const std::string& patchName) const {
    return itsRep->patchExists(patchName);
  }
 
  bool sourceExists(const std::string& sourceName) const {
    return itsRep->sourceExists(sourceName);
  }
 
  unsigned int addPatch(const std::string& patchName, int catType,
                        double apparentBrightness, double ra, double dec,
                        bool check) override {
    return itsRep->addPatch(patchName, catType, apparentBrightness, ra, dec,
                            check);
  }
 
  void updatePatch(unsigned int patchId, double apparentBrightness, double ra,
                   double dec) override {
    itsRep->updatePatch(patchId, apparentBrightness, ra, dec);
  }
 
  void addSource(const SourceInfo& sourceInfo, const std::string& patchName,
                 const ParmMap& defaultParameters, double ra, double dec,
                 bool check) override {
    itsRep->addSource(sourceInfo, patchName, defaultParameters, ra, dec, check);
  }
  void addSource(const SourceData& source, bool check = true) {
    itsRep->addSource(source, check);
  }
 
  void addSource(const SourceInfo& sourceInfo, const std::string& patchName,
                 int catType, double apparentBrightness,
                 const ParmMap& defaultParameters, double ra, double dec,
                 bool check) override {
    itsRep->addSource(sourceInfo, patchName, catType, apparentBrightness,
                      defaultParameters, ra, dec, check);
  }
 
  std::vector<std::string> getPatches(
      int category = -1, const std::string& pattern = std::string(),
      double minBrightness = -1, double maxBrightness = -1) const {
    return itsRep->getPatches(category, pattern, minBrightness, maxBrightness);
  }
 
  std::vector<PatchInfo> getPatchInfo(
      int category = -1, const std::string& pattern = std::string(),
      double minBrightness = -1, double maxBrightness = -1) const {
    return itsRep->getPatchInfo(category, pattern, minBrightness,
                                maxBrightness);
  }
 
  std::vector<SourceInfo> getPatchSources(const std::string& patchName) const {
    return itsRep->getPatchSources(patchName);
  }
 
  std::vector<SourceData> getPatchSourceData(
      const std::string& patchName) const {
    return itsRep->getPatchSourceData(patchName);
  }
 
  SourceInfo getSource(const std::string& sourceName) const {
    return itsRep->getSource(sourceName);
  }
 
  std::vector<SourceInfo> getSources(
      const std::string& sourceNamePattern) const {
    return itsRep->getSources(sourceNamePattern);
  }
 
  void deleteSources(const std::string& sourceNamePattern) {
    itsRep->deleteSources(sourceNamePattern);
  }
 
  void clearTables() { itsRep->clearTables(); }
 
  const ParmDBMeta& getParmDBMeta() const { return itsRep->getParmDBMeta(); }
 
  void getNextSource(SourceData& src) { itsRep->getNextSource(src); }
 
  bool atEnd() { return itsRep->atEnd(); }
 
  void rewind() { itsRep->rewind(); }
 
 private:
  SourceDB(SourceDBRep*);
 
  void decrCount();
 
  SourceDBRep* itsRep;
 
  std::filesystem::path itsSourceDBPath;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif