dyscostmancol.h

Go to the documentation of this file.

#ifndef DYSCO_STORAGE_MAN_COLUMN_H
#define DYSCO_STORAGE_MAN_COLUMN_H

#include "dyscodistribution.h"
#include "dysconormalization.h"

#include <casacore/tables/DataMan/StManColumnBase.h>

#include <casa/Arrays/IPosition.h>

#include <cstdint>
#include <map>

namespace dyscostman {

class DyscoStMan;

class DyscoStManColumn : public casacore::StManColumnBase {
 public:
  explicit DyscoStManColumn(DyscoStMan *parent, int dtype)
      : casacore::StManColumnBase(dtype),
        _offsetInBlock(0),
        _storageManager(parent) {}

  virtual ~DyscoStManColumn() {}

  virtual void shutdown() = 0;

  virtual casacore::Bool isWritable() const override { return true; }

  virtual void Prepare(DyscoDistribution distribution,
                       Normalization normalization, double studentsTNu,
                       double distributionTruncation) = 0;

  virtual void InitializeAfterNRowsPerBlockIsKnown() = 0;

  virtual size_t CalculateBlockSize(size_t nRowsInBlock,
                                    size_t nAntennae) const = 0;

  virtual size_t ExtraHeaderSize() const { return 0; }

  virtual void SerializeExtraHeader(std::ostream &stream) const = 0;

  virtual void UnserializeExtraHeader(std::istream &stream) = 0;

  size_t OffsetInBlock() const { return _offsetInBlock; }

  void SetOffsetInBlock(size_t offsetInBlock) {
    _offsetInBlock = offsetInBlock;
  }

 protected:
  DyscoStMan &storageManager() const { return *_storageManager; }

  void readCompressedData(size_t blockIndex, unsigned char *dest, size_t size);

  void writeCompressedData(size_t blockIndex, const unsigned char *data,
                           size_t size);

  uint64_t nBlocksInFile() const;

  size_t getBlockIndex(uint64_t row) const;

  size_t getRowWithinBlock(uint64_t row) const;

  size_t nRowsInBlock() const;

  size_t nAntennae() const;

  uint64_t getRowIndex(size_t block) const;

  bool areOffsetsInitialized() const;

  void initializeRowsPerBlock(size_t rowsPerBlock, size_t antennaCount);

 private:
  DyscoStManColumn(const DyscoStManColumn &source) = delete;
  void operator=(const DyscoStManColumn &source) = delete;

  size_t _offsetInBlock;
  DyscoStMan *_storageManager;
};

}  // namespace dyscostman

#include "dyscostman.h"

namespace dyscostman {

inline void DyscoStManColumn::readCompressedData(size_t blockIndex,
                                                 unsigned char *dest,
                                                 size_t size) {
  _storageManager->readCompressedData(blockIndex, this, dest, size);
}

inline void DyscoStManColumn::writeCompressedData(size_t blockIndex,
                                                  const unsigned char *data,
                                                  size_t size) {
  _storageManager->writeCompressedData(blockIndex, this, data, size);
}

inline uint64_t DyscoStManColumn::nBlocksInFile() const {
  return _storageManager->nBlocksInFile();
}

inline size_t DyscoStManColumn::getBlockIndex(uint64_t row) const {
  return _storageManager->getBlockIndex(row);
}

inline size_t DyscoStManColumn::nRowsInBlock() const {
  return _storageManager->nRowsInBlock();
}

inline size_t DyscoStManColumn::nAntennae() const {
  return _storageManager->nAntennae();
}

inline uint64_t DyscoStManColumn::getRowIndex(size_t block) const {
  return _storageManager->getRowIndex(block);
}

inline size_t DyscoStManColumn::getRowWithinBlock(uint64_t rowIndex) const {
  return _storageManager->getRowWithinBlock(rowIndex);
}

inline bool DyscoStManColumn::areOffsetsInitialized() const {
  return _storageManager->areOffsetsInitialized();
}

inline void DyscoStManColumn::initializeRowsPerBlock(size_t rowsPerBlock,
                                                     size_t antennaCount) {
  _storageManager->initializeRowsPerBlock(rowsPerBlock, antennaCount, true);
}

}  // namespace dyscostman

#endif