ParmDB.h

Go to the documentation of this file.

// ParmDB.h: Base class for a table holding parameters
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_PARMDB_H
#define LOFAR_PARMDB_PARMDB_H
 
#include "ParmMap.h"
#include "ParmDBMeta.h"
#include "ParmSet.h"
 
#include <vector>
#include <map>
 
namespace dp3 {
namespace parmdb {
 
 
class ParmDBRep {
 public:
  ParmDBRep();
 
  virtual ~ParmDBRep();
 
  void link() { itsCount++; }
 
  int unlink() { return --itsCount; }
 
  virtual void flush(bool fsync);
 
  virtual void lock(bool lockForWrite);
  virtual void unlock();
 
  virtual Box getRange(const std::string& parmNamePattern) const = 0;
  virtual Box getRange(const std::vector<std::string>& parmNames) const = 0;
 
  const std::vector<double>& getDefaultSteps() const { return itsDefSteps; }
 
  virtual void setDefaultSteps(const std::vector<double>&) = 0;
 
  virtual void getValuesPattern(ParmMap& result,
                                const std::string& parmNamePattern,
                                const Box& domain);
 
  virtual void getValues(std::vector<ParmValueSet>& values,
                         const std::vector<unsigned int>& nameIds,
                         const std::vector<ParmId>& parmIds,
                         const Box& domain) = 0;
 
  virtual void putValues(const std::string& parmName, int& nameId,
                         ParmValueSet& values) = 0;
 
  // virtual void putValues (ParmMap& parmSet) = 0;
 
  virtual void deleteValues(const std::string& parmNamePattern,
                            const Box& domain) = 0;
 
  ParmValueSet getDefValue(const std::string& parmName,
                           const ParmValue& defaultValue);
 
  virtual void getDefValues(ParmMap& result,
                            const std::string& parmNamePattern) = 0;
 
  virtual void putDefValue(const std::string& parmName,
                           const ParmValueSet& value, bool check = true) = 0;
 
  virtual void deleteDefValues(const std::string& parmNamePattern) = 0;
 
  virtual std::vector<std::string> getNames(const std::string& pattern) = 0;
 
  virtual int getNameId(const std::string& parmName) = 0;
 
  virtual void clearTables() = 0;
 
  void setParmDBMeta(const ParmDBMeta& ptm) { itsPTM = ptm; }
  const ParmDBMeta& getParmDBMeta() const { return itsPTM; }
 
  void setParmDBSeqNr(int seqnr) { itsSeqNr = seqnr; }
  int getParmDBSeqNr() const { return itsSeqNr; }
 
  void clearDefFilled() { itsDefFilled = false; }
 
 protected:
  void setDefStep(unsigned int i, double value) { itsDefSteps[i] = value; }
 
 private:
  virtual void fillDefMap(ParmMap& defMap) = 0;
 
  int itsCount;
  ParmDBMeta itsPTM;
  int itsSeqNr;
  bool itsDefFilled;
  ParmMap itsDefValues;
  std::vector<double> itsDefSteps;
};
 
class ParmDB {
 public:
  explicit ParmDB(const ParmDBMeta& ptm, bool forceNew = false);
 
  ParmDB(const ParmDB&);
 
  ~ParmDB() { decrCount(); }
 
  ParmDB& operator=(const ParmDB&);
 
  void flush(bool fsync = false) { itsRep->flush(fsync); }
 
  void lock(bool lockForWrite = true) { itsRep->lock(lockForWrite); }
  void unlock() { itsRep->unlock(); }
 
  Box getRange(const std::string& parmNamePattern = "") const {
    return itsRep->getRange(parmNamePattern);
  }
  Box getRange(const std::vector<std::string>& parmNames) const {
    return itsRep->getRange(parmNames);
  }
 
  const std::vector<double>& getDefaultSteps() const {
    return itsRep->getDefaultSteps();
  }
 
  void setDefaultSteps(const std::vector<double>& steps) {
    itsRep->setDefaultSteps(steps);
  }
 
  void getValues(ParmMap& result, const std::string& parmNamePattern,
                 const Box& domain) const {
    itsRep->getValuesPattern(result, parmNamePattern, domain);
  }
 
  void getValues(std::vector<ParmValueSet>& values,
                 const std::vector<unsigned int>& nameIds,
                 const std::vector<ParmId>& parmIds, const Box& domain) {
    itsRep->getValues(values, nameIds, parmIds, domain);
  }
 
  void putValues(const std::string& name, int& nameId, ParmValueSet& values) {
    itsRep->putValues(name, nameId, values);
  }
 
  void deleteValues(const std::string& parmNamePattern, const Box& domain) {
    itsRep->deleteValues(parmNamePattern, domain);
  }
 
  ParmValueSet getDefValue(const std::string& parmName,
                           const ParmValue& defaultValue = ParmValue()) const {
    return itsRep->getDefValue(parmName, defaultValue);
  }
 
  void getDefValues(ParmMap& result, const std::string& parmNamePattern) const {
    itsRep->getDefValues(result, parmNamePattern);
  }
 
  void putDefValue(const std::string& parmName, const ParmValueSet& value,
                   bool check = true) {
    itsRep->putDefValue(parmName, value, check);
  }
 
  void deleteDefValues(const std::string& parmNamePattern) {
    itsRep->deleteDefValues(parmNamePattern);
  }
 
  std::vector<std::string> getNames(const std::string& pattern) const {
    return itsRep->getNames(pattern);
  }
 
  int getNameId(const std::string& parmName) {
    return itsRep->getNameId(parmName);
  }
 
  void clearTables() { itsRep->clearTables(); }
 
  const ParmDBMeta& getParmDBMeta() const { return itsRep->getParmDBMeta(); }
 
  int getParmDBSeqNr() const { return itsRep->getParmDBSeqNr(); }
 
  static ParmDB getParmDB(unsigned int index);
 
 private:
  ParmDB(ParmDBRep*);
 
  void decrCount();
 
  ParmDBRep* itsRep;
 
  static std::map<std::string, int> theirDBNames;
  static std::vector<ParmDBRep*> theirParmDBs;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif