NWBFile.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include "Types.hpp"
#include "Utils.hpp"
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "nwb/RecordingContainers.hpp"
#include "nwb/base/TimeSeries.hpp"
#include "nwb/file/ElectrodesTable.hpp"
#include "nwb/hdmf/base/Container.hpp"
#include "spec/core.hpp"

namespace AQNWB::NWB
{

class NWBFile : public Container
{
public:
  // Register the ElectrodesTable as a subclass of Container
  REGISTER_SUBCLASS(NWBFile, AQNWB::SPEC::CORE::namespaceName)
 
  
  NWBFile(std::shared_ptr<IO::BaseIO> io);

  NWBFile(const std::string& path, std::shared_ptr<IO::BaseIO> io);

  NWBFile(const NWBFile&) = delete;

  NWBFile& operator=(const NWBFile&) = delete;

  ~NWBFile();

  Status initialize(const std::string& identifierText,
                    const std::string& description = "a recording session",
                    const std::string& dataCollection = "",
                    const std::string& sessionStartTime = "",
                    const std::string& timestampsReferenceTime = "");

  bool isInitialized() const;

  Status finalize();

  Status createElectrodesTable(
      std::vector<Types::ChannelVector> recordingArrays);

  Status createElectricalSeries(
      std::vector<Types::ChannelVector> recordingArrays,
      std::vector<std::string> recordingNames,
      const IO::BaseDataType& dataType,
      RecordingContainers* recordingContainers,
      std::vector<SizeType>& containerIndexes);

  Status createSpikeEventSeries(
      std::vector<Types::ChannelVector> recordingArrays,
      std::vector<std::string> recordingNames,
      const IO::BaseDataType& dataType,
      RecordingContainers* recordingContainers,
      std::vector<SizeType>& containerIndexes);

  Status createAnnotationSeries(std::vector<std::string> recordingNames,
                                RecordingContainers* recordingContainers,
                                std::vector<SizeType>& containerIndexes);
 
  DEFINE_REGISTERED_FIELD(readElectrodesTable,
                          ElectrodesTable,
                          ElectrodesTable::electrodesTablePath,
                          "table with the extracellular electrodes")
 
  DEFINE_ATTRIBUTE_FIELD(readNWBVersion,
                         std::string,
                         "nwb_version",
                         File version string)
 
  DEFINE_DATASET_FIELD(readFileCreateDate,
                       recordFileCreateDate,
                       std::string,
                       "file_create_date",
                       A record of the date the file was created and of
                           subsequent modifications)
 
  DEFINE_DATASET_FIELD(readIdentifier,
                      recordIdentifier,
                      std::string,
                      "identifier",
                      A unique text identifier for the file)
 
  DEFINE_DATASET_FIELD(readSessionDescription,
                       recordSessionDescription,
                       std::string,
                       "session_description",
                       A description of the experimental session and data in the
                           file)
 
  DEFINE_DATASET_FIELD(readSessionStartTime,
                       recordSessionStartTime,
                       std::string,
                       "session_start_time",
                       Date and time of the experiment or session start)
 
  DEFINE_DATASET_FIELD(readTimestampsReferenceTime,
                       recordTimestampsReferenceTime,
                       std::string,
                       "timestamps_reference_time",
                       Date and time corresponding to time zero of all
                           timestamps)
 
protected:
  Status createFileStructure(const std::string& identifierText,
                             const std::string& description,
                             const std::string& dataCollection,
                             const std::string& sessionStartTime,
                             const std::string& timestampsReferenceTime);
 
private:
  void cacheSpecifications(const Types::NamespaceInfo& namespaceInfo);
 
  inline const static std::string m_acquisitionPath = "/acquisition";
 
  inline const static std::string m_specificationsPath = "/specifications";

  std::unique_ptr<ElectrodesTable> m_electrodeTable;
};
 
}  // namespace AQNWB::NWB