ParmDBCasa.h

Go to the documentation of this file.

// ParmDBCasa.h: Class to hold parameters in a Casa table
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_PARMDBCASA_H
#define LOFAR_PARMDB_PARMDBCASA_H
 
#include "ParmDB.h"
 
#include <casacore/casa/Arrays/Array.h>
#include <casacore/tables/Tables/Table.h>
#include <casacore/tables/Tables/ArrayColumn.h>
 
#include "common/Types.h"
 
namespace dp3 {
namespace parmdb {
 
 
class ParmDBCasa : public ParmDBRep {
 public:
  explicit ParmDBCasa(const std::string& tableName, bool forceNew = false);
 
  ~ParmDBCasa() override;
 
  void flush(bool fsync) override;
 
  void lock(bool lockForWrite) override;
  void unlock() override;
 
  Box getRange(const std::string& parmNamePattern) const override;
  Box getRange(const std::vector<std::string>& parmNames) const override;
 
  void setDefaultSteps(const std::vector<double>&) override;
 
  void getValues(std::vector<ParmValueSet>& values,
                 const std::vector<unsigned int>& nameIds,
                 const std::vector<ParmId>& parmIds,
                 const Box& domain) override;
 
  void putValues(const std::string& parmName, int& nameId,
                 ParmValueSet& values) override;
 
  void deleteValues(const std::string& parmNamePattern,
                    const Box& domain) override;
 
  void getDefValues(ParmMap& result,
                    const std::string& parmNamePattern) override;
 
  void putDefValue(const std::string& name, const ParmValueSet& value,
                   bool check = true) override;
 
  void deleteDefValues(const std::string& parmNamePattern) override;
 
  std::vector<std::string> getNames(const std::string& pattern) override;
 
  int getNameId(const std::string& parmName) override;
 
  void clearTables() override;
 
 private:
  void fillDefMap(ParmMap& defMap) override;
 
  void createTables(const std::string& tableName);
 
  void putDefDomain(const Box& domain, casacore::Table& tab,
                    unsigned int rownr);
 
  Box getDefDomain(const casacore::Table& tab, unsigned int row);
 
  casacore::Table getNameSel(const std::string& parmNamePattern) const;
  casacore::Vector<common::rownr_t> getNameIds(
      const std::string& parmNamePattern) const;
  casacore::Vector<common::rownr_t> getNameIds(
      const std::vector<std::string>& parmNames) const;
 
  Box findRange(const casacore::Table& table) const;
 
  // void extractValues (ParmMap& result, const casacore::Table& table);
  std::pair<string, ParmValueSet> extractDefValue(const casacore::Table& sel,
                                                  int row);
 
  void doPutValue(const std::string& parmName, int& nameId,
                  ParmValueSet& parmSet);
 
  void putOldValue(const ParmValue& parmValue, ParmValue::FunkletType type);
 
  void putNewValue(const std::string& name, int& nameId, ParmValueSet& parmSet,
                   ParmValue& parmValue, const Box& domain);
 
  int putName(const std::string& name, const ParmValueSet& pset);
 
  void putNewDefValue(const std::string& parmName, const ParmValueSet& value);
 
  void putInterval(const Axis& axis, casacore::ArrayColumn<double>& col,
                   unsigned int rownr);
 
  Axis::ShPtr getInterval(casacore::ROArrayColumn<double>& col,
                          unsigned int rownr, double st, double end,
                          unsigned int n);
 
  casacore::Table find(const std::string& parmName, const Box& domain);
 
  casacore::TableExprNode makeExpr(const casacore::Table& table,
                                   const Box& domain) const;
 
  void andExpr(casacore::TableExprNode& expr,
               const casacore::TableExprNode& right) const;
 
  casacore::Table itsTables[3];  
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif