Subject.hpp

Go to the documentation of this file.

#pragma once
 
// Common STL includes
#include <memory>
#include <optional>
#include <string>
#include <vector>
// Base AqNWB includes for IO and RegisteredType
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
#include "nwb/RegisteredType.hpp"
// Include for parent type
#include "nwb/base/NWBContainer.hpp"
// Include for the namespace schema header
#include "spec/core.hpp"
 
namespace AQNWB::NWB
{

class Subject : public AQNWB::NWB::NWBContainer
{
public:
  REGISTER_SUBCLASS(Subject, NWBContainer, AQNWB::SPEC::CORE::namespaceName)
 
  
  struct SubjectSpec
  {
    std::optional<std::string> age = std::nullopt;
    std::optional<std::string> ageReference = std::nullopt;
    std::optional<std::string> dateOfBirth = std::nullopt;
    std::optional<std::string> description = std::nullopt;
    std::optional<std::string> genotype = std::nullopt;
    std::optional<std::string> sex = std::nullopt;
    std::optional<std::string> species = std::nullopt;
    std::optional<std::string> strain = std::nullopt;
    std::optional<std::string> subjectId = std::nullopt;
    std::optional<std::string> weight = std::nullopt;

    SubjectSpec& withAge(std::string value)
    {
      age = std::move(value);
      return *this;
    }

    SubjectSpec& withAgeReference(std::string value)
    {
      ageReference = std::move(value);
      return *this;
    }

    SubjectSpec& withDateOfBirth(std::string value)
    {
      dateOfBirth = std::move(value);
      return *this;
    }

    SubjectSpec& withDescription(std::string value)
    {
      description = std::move(value);
      return *this;
    }

    SubjectSpec& withGenotype(std::string value)
    {
      genotype = std::move(value);
      return *this;
    }

    SubjectSpec& withSex(std::string value)
    {
      sex = std::move(value);
      return *this;
    }

    SubjectSpec& withSpecies(std::string value)
    {
      species = std::move(value);
      return *this;
    }

    SubjectSpec& withStrain(std::string value)
    {
      strain = std::move(value);
      return *this;
    }

    SubjectSpec& withSubjectId(std::string value)
    {
      subjectId = std::move(value);
      return *this;
    }

    SubjectSpec& withWeight(std::string value)
    {
      weight = std::move(value);
      return *this;
    }
  };

  static std::shared_ptr<Subject> create(std::shared_ptr<IO::BaseIO> io);

  virtual ~Subject() override {}

  Status initialize(const SubjectSpec& subjectSpec);
 
  // Define read methods
  DEFINE_DATASET_FIELD(
      readAge,
      recordAge,
      std::string,
      "age",
      "Age of subject. Can be supplied instead of date_of_birth.")
 
  DEFINE_DATASET_FIELD(
      readDateOfBirth,
      recordDateOfBirth,
      std::string,
      "date_of_birth",
      "Date of birth of subject. Can be supplied instead of age.")
 
  DEFINE_DATASET_FIELD(readDescription,
                       recordDescription,
                       std::string,
                       "description",
                       "Description of subject and where subject came from "
                       "(e.g. - breeder - if animal).")
 
  DEFINE_DATASET_FIELD(readGenotype,
                       recordGenotype,
                       std::string,
                       "genotype",
                       "Genetic strain. If absent - assume Wild Type (WT).")
 
  DEFINE_DATASET_FIELD(
      readSex, recordSex, std::string, "sex", "Gender of subject.")
 
  DEFINE_DATASET_FIELD(
      readSpecies, recordSpecies, std::string, "species", "Species of subject.")
 
  DEFINE_DATASET_FIELD(
      readStrain, recordStrain, std::string, "strain", "Strain of subject.")
 
  DEFINE_DATASET_FIELD(
      readSubjectId,
      recordSubjectId,
      std::string,
      "subject_id",
      "ID of animal/person used/participating in experiment (lab convention).")
 
  DEFINE_DATASET_FIELD(readWeight,
                       recordWeight,
                       std::string,
                       "weight",
                       "Weight at time of experiment - at time of surgery and "
                       "at other important times.")
 
  DEFINE_ATTRIBUTE_FIELD(
      readAgeReference,
      std::string,
      "age/reference",
      "Age is with reference to this event. Can be birth or gestational. If "
      "reference is omitted - birth is implied.")
 
protected:
  explicit Subject(std::shared_ptr<IO::BaseIO> io);

  Subject(const std::string& path, std::shared_ptr<AQNWB::IO::BaseIO> io);
};
 
}  // namespace AQNWB::NWB