ParmFacade.h

Go to the documentation of this file.

// ParmFacade.h: Data access the parameter database
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_PARMDB_PARMFACADE_H
#define LOFAR_PARMDB_PARMFACADE_H
 
#include "ParmFacadeRep.h"
 
namespace dp3 {
namespace parmdb {
 
 
 
//
//
class ParmFacade {
 public:
  ParmFacade(const std::string& tableName, bool create = false);
 
  ~ParmFacade();
 
  string version(const std::string& type) const;
 
  std::vector<double> getRange(
      const std::string& parmNamePattern = std::string()) const {
    return itsRep->getRange(parmNamePattern);
  }
 
  std::vector<std::string> getNames(
      const std::string& parmNamePattern = std::string(),
      bool includeDefaults = false) const {
    return itsRep->getNames(parmNamePattern, includeDefaults);
  }
 
  std::vector<std::string> getDefNames(
      const std::string& parmNamePattern = std::string()) const {
    return itsRep->getDefNames(parmNamePattern);
  }
 
  casacore::Record getDefValues(
      const std::string& parmNamePattern = std::string()) const {
    return itsRep->getDefValues(parmNamePattern);
  }
 
  std::map<std::string, std::vector<double>> getValuesMap(
      const std::string& parmNamePattern, double freqv1, double freqv2,
      double freqStep, double timev1, double timev2, double timeStep,
      bool asStartEnd = false, bool includeDefaults = false);
  std::map<std::string, std::vector<double>> getValuesMap(
      const std::string& parmNamePattern, double freqv1, double freqv2,
      double timev1, double timev2, bool asStartEnd = false,
      bool includeDefaults = false) {
    return getValuesMap(parmNamePattern, freqv1, freqv2, 0, timev1, timev2,
                        asStartEnd, includeDefaults);
  }
 
  casacore::Record getValues(const std::string& parmNamePattern, double freqv1,
                             double freqv2, double freqStep, double timev1,
                             double timev2, double timeStep,
                             bool asStartEnd = true,
                             bool includeDefaults = false) {
    return itsRep->getValues(parmNamePattern, freqv1, freqv2, freqStep, timev1,
                             timev2, timeStep, asStartEnd, includeDefaults);
  }
  casacore::Record getValues(const std::string& parmNamePattern,
                             double freqv1 = -1e30, double freqv2 = 1e30,
                             double timev1 = -1e30, double timev2 = 1e30,
                             bool asStartEnd = true,
                             bool includeDefaults = false);
 
  casacore::Record getValues(const std::string& parmNamePattern,
                             const std::vector<double>& freqv1,
                             const std::vector<double>& freqv2,
                             const std::vector<double>& timev1,
                             const std::vector<double>& timev2,
                             bool asStartEnd = true,
                             bool includeDefaults = false) {
    return itsRep->getValues(parmNamePattern, freqv1, freqv2, timev1, timev2,
                             asStartEnd, includeDefaults);
  }
 
  casacore::Record getValuesGrid(const std::string& parmNamePattern,
                                 double freqv1 = -1e30, double freqv2 = 1e30,
                                 double timev1 = -1e30, double timev2 = 1e30,
                                 bool asStartEnd = true) {
    return itsRep->getValuesGrid(parmNamePattern, freqv1, freqv2, timev1,
                                 timev2, asStartEnd);
  }
 
  casacore::Record getCoeff(const std::string& parmNamePattern,
                            double freqv1 = -1e30, double freqv2 = 1e30,
                            double timev1 = -1e30, double timev2 = 1e30,
                            bool asStartEnd = true) {
    return itsRep->getCoeff(parmNamePattern, freqv1, freqv2, timev1, timev2,
                            asStartEnd);
  }
 
  void clearTables() { itsRep->clearTables(); }
 
  void addDefValues(const casacore::Record& rec, bool check = true) {
    return itsRep->addDefValues(rec, check);
  }
 
  void deleteDefValues(const std::string& parmNamePattern) {
    return itsRep->deleteDefValues(parmNamePattern);
  }
 
  void flush(bool fsync = false) { itsRep->flush(fsync); }
 
 
  void lock(bool lockForWrite) { itsRep->lock(lockForWrite); }
  void unlock() { itsRep->unlock(); }
 
  std::vector<double> getDefaultSteps() const {
    return itsRep->getDefaultSteps();
  }
 
  void setDefaultSteps(const std::vector<double>& steps) {
    itsRep->setDefaultSteps(steps);
  }
 
  void addValues(const casacore::Record& rec) { itsRep->addValues(rec); }
 
  void deleteValues(const std::string& parmNamePattern, double freqv1 = -1e30,
                    double freqv2 = 1e30, double timev1 = -1e30,
                    double timev2 = 1e30, bool asStartEnd = true) {
    itsRep->deleteValues(parmNamePattern, freqv1, freqv2, timev1, timev2,
                         asStartEnd);
  }
 
 private:
  std::map<std::string, std::vector<double>> record2Map(
      const casacore::Record& rec) const;
 
  ParmFacadeRep::ShPtr itsRep;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif