StokesIStMan.h

Go to the documentation of this file.

#ifndef CASACORE_STOKES_I_STORAGE_MANAGER_H_
#define CASACORE_STOKES_I_STORAGE_MANAGER_H_
 
#include <casacore/tables/DataMan/DataManager.h>
 
#include <casacore/casa/Containers/Record.h>
 
#include "BufferedColumnarFile.h"
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern "C" {
#endif
void register_stokesistman();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
 
namespace casacore {
 
class StokesIStManColumn;

class StokesIStMan final : public casacore::DataManager {
 public:
  StokesIStMan(const casacore::String &name, const casacore::Record &spec);

  StokesIStMan(const StokesIStMan &source);
 
  ~StokesIStMan() noexcept;

  StokesIStMan &operator=(const StokesIStMan &source) = delete;
 
  casacore::DataManager *clone() const final { return new StokesIStMan(*this); }
  static casacore::DataManager *makeObject(const casacore::String &name,
                                           const casacore::Record &spec) {
    return new StokesIStMan(name, spec);
  }
 
  casacore::String dataManagerType() const final { return "StokesIStMan"; }
 
  casacore::Record dataManagerSpec() const final;
 
  casacore::Bool canAddRow() const final { return true; }
 
  casacore::Bool canRemoveRow() const final { return true; }
 
  casacore::Bool canAddColumn() const final { return true; }
 
  casacore::Bool canRemoveColumn() const final { return true; }

  static void registerClass();
 
 protected:
 private:
  friend class StokesIStManColumn;
 
  uint64_t CalculateAndUpdateStride();
 
  casacore::Bool flush(casacore::AipsIO &, [[maybe_unused]] casacore::Bool doFsync) final {
    return false;
  }
 
  // Let the storage manager create files as needed for a new table.
  // This allows a column with an indirect array to create its file.
  void create64(casacore::rownr_t nRow) final;
 
  // Open the storage manager file for an existing table.
  // Return the number of rows in the data file.
  casacore::rownr_t open64(casacore::rownr_t nRow, casacore::AipsIO &) final;
 
  // Create a column in the storage manager on behalf of a table column.
  // The caller will NOT delete the newly created object.
  // Create a scalar column.
  casacore::DataManagerColumn *makeScalarColumn(const casacore::String &name, int dataType,
                                                const casacore::String &dataTypeID) final;
 
  // Create a direct array column.
  casacore::DataManagerColumn *makeDirArrColumn(const casacore::String &name, int dataType,
                                                const casacore::String &dataTypeID) final;
 
  // Create an indirect array column.
  casacore::DataManagerColumn *makeIndArrColumn(const casacore::String &name, int dataType,
                                                const casacore::String &dataTypeID) final;
 
  casacore::rownr_t resync64(casacore::rownr_t nRow) final;
 
  void deleteManager() final;
 
  // Prepare the columns, let the data manager initialize itself further.
  // Prepare is called after create/open has been called for all
  // columns. In this way one can be sure that referenced columns
  // are read back and partly initialized.
  void prepare() final;
 
  // Reopen the storage manager files for read/write.
  void reopenRW() final;
 
  // Add rows to the storage manager.
  void addRow64(casacore::rownr_t nrrow) final;
 
  // Delete a row from all columns.
  void removeRow64(casacore::rownr_t row_nr) final;
 
  // Do the final addition of a column.
  void addColumn(casacore::DataManagerColumn *) final;
 
  // Remove a column from the data file.
  void removeColumn(casacore::DataManagerColumn *) final;
 
  std::string name_;
  // The item-type needs to be a pointer, because casacore::StManColumn
  // does not have move construct/assignment.
  std::vector<std::unique_ptr<StokesIStManColumn>> columns_;
  BufferedColumnarFile file_;
  constexpr static size_t kHeaderSize = 8;
  constexpr static const char kMagicHeaderTag[8] = "StkIcol";
};
 
}  // namespace casacore
 
#endif