Update handling of colnames

docs/pages/userdocs/read.dox

@@ -123,9 +123,12 @@
  * - \ref AQNWB::IO::BaseIO "BaseIO", \ref AQNWB::IO::HDF5::HDF5IO "HDF5IO" responsible for
  *   reading data from disk and allocating memory for data on read
  * - \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric" represents a generic, n-dimensional block of data
- *   loaded from a file, storing the data as a generic ``std::any`` along with the ``shape`` of the data.
- *   - \ref AQNWB::IO::DataBlock "DataBlock" represents a typed, n-dimensional block of data, derived
- *     from a \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric"
+ *   loaded from a file, storing the data as a generic ``std::any`` along with the ``shape`` of the data
+ *   (i.e., the ``std::any`` represents a ``std::vector<DTYPE>`` so that we can cast it to the 
+ *   ``std::any_cast<std::vector<DTYPE>>(genericDataBlock.data)`` without having to copy data)
+ * - \ref AQNWB::IO::DataBlock "DataBlock" represents a typed, n-dimensional block of data, derived
+ *   from a \ref AQNWB::IO::DataBlockGeneric "DataBlockGeneric". I.e., here the data has been 
+ *   cast to the correct ``std::vector<DTYPE>``.
  * - \ref AQNWB::IO::ReadDataWrapper "ReadDataWrapper", is a simple wrapper class that represents
  *   a dataset/attribute for read, enabling lazy data read and allowing for transparent use of different I/O backends.
  * - \ref AQNWB::NWB::Container "Container" type classes represent Groups with an assigned ``neurodata_type``

src/Types.hpp

@@ -24,6 +24,28 @@ class Types
     Failure = -1
   };
 
+  /**
+   * @brief Overloaded && operator for Status enum
+   * @param lhs Left-hand side Status
+   * @param rhs Right-hand side Status
+   * @return Success if both statuses are Success, Failure otherwise
+   */
+  friend Status operator&&(Status lhs, Status rhs)
+  {
+    return (lhs == Success && rhs == Success) ? Success : Failure;
+  }
+
+  /**
+   * @brief Overloaded || operator for Status enum
+   * @param lhs Left-hand side Status
+   * @param rhs Right-hand side Status
+   * @return Success if either status is Success, Failure otherwise
+   */
+  friend Status operator||(Status lhs, Status rhs)
+  {
+    return (lhs == Success || rhs == Success) ? Success : Failure;
+  }
+
   /**
    * @brief Types of object used in the NWB schema
    */

src/io/BaseIO.hpp

@@ -329,11 +329,13 @@ class BaseIO
    * @param data The string array attribute data.
    * @param path The location in the file to set the attribute.
    * @param name The name of the attribute.
+   * @param overwrite Overwrite the attribute if it already exists.
    * @return The status of the attribute creation operation.
    */
   virtual Status createAttribute(const std::vector<std::string>& data,
                                  const std::string& path,
-                                 const std::string& name) = 0;
+                                 const std::string& name,
+                                 const bool overwrite = false) = 0;
 
   /**
    * @brief Creates a string array attribute at a given location in the file.

src/io/hdf5/HDF5IO.cpp

@@ -38,7 +38,7 @@ Status HDF5IO::open()
 
 Status HDF5IO::open(FileMode mode)
 {
-  int accFlags = 0;
+  unsigned int accFlags = 0;
 
   if (m_opened) {
     return Status::Failure;
@@ -683,17 +683,82 @@ Status HDF5IO::createAttribute(const std::string& data,
 
 Status HDF5IO::createAttribute(const std::vector<std::string>& data,
                                const std::string& path,
-                               const std::string& name)
+                               const std::string& name,
+                               const bool overwrite)
 {
-  std::vector<const char*> dataPtrs;
-  SizeType maxLength = 0;
-  for (const std::string& str : data) {
-    SizeType length = str.length();
-    maxLength = std::max(maxLength, length);
-    dataPtrs.push_back(str.c_str());
+  H5Object* loc;
+  Group gloc;
+  DataSet dloc;
+  Attribute attr;
+  hsize_t dims[1];
+
+  if (!canModifyObjects()) {
+    return Status::Failure;
+  }
+
+  // Create variable length string type
+  StrType H5type(PredType::C_S1, H5T_VARIABLE);
+
+  // open the group or dataset
+  H5O_type_t objectType = getH5ObjectType(path);
+  switch (objectType) {
+    case H5O_TYPE_GROUP:
+      gloc = m_file->openGroup(path);
+      loc = &gloc;
+      break;
+    case H5O_TYPE_DATASET:
+      dloc = m_file->openDataSet(path);
+      loc = &dloc;
+      break;
+    default:
+      return Status::Failure;  // not a valid dataset or group type
   }
 
-  return createAttribute(dataPtrs, path, name, maxLength + 1);
+  try {
+    if (loc->attrExists(name)) {
+      if (overwrite) {
+        // Delete the existing attribute
+        loc->removeAttr(name);
+      } else {
+        return Status::Failure;  // don't allow overwriting
+      }
+    }
+
+    // Create dataspace based on number of strings
+    DataSpace attr_dataspace;
+    if (data.size() > 1) {
+      dims[0] = data.size();
+      attr_dataspace = DataSpace(1, dims);
+    } else {
+      attr_dataspace = DataSpace(H5S_SCALAR);
+    }
+
+    // Create the attribute
+    attr = loc->createAttribute(name, H5type, attr_dataspace);
+
+    // Write the data directly from the vector of strings
+    std::vector<const char*> dataPtrs;
+    dataPtrs.reserve(data.size());
+    for (const auto& str : data) {
+      dataPtrs.push_back(str.c_str());
+    }
+    attr.write(H5type, dataPtrs.data());
+
+  } catch (GroupIException error) {
+    error.printErrorStack();
+    return Status::Failure;
+  } catch (AttributeIException error) {
+    error.printErrorStack();
+    return Status::Failure;
+  } catch (FileIException error) {
+    error.printErrorStack();
+    return Status::Failure;
+  } catch (DataSetIException error) {
+    error.printErrorStack();
+    return Status::Failure;
+  }
+
+  return Status::Success;
 }
 
 Status HDF5IO::createAttribute(const std::vector<const char*>& data,

src/io/hdf5/HDF5IO.hpp

@@ -152,18 +152,22 @@ class HDF5IO : public BaseIO
                          const std::string& name) override;
 
   /**
-   * @brief Creates a string array attribute at a given location in the file.
+   * @brief Creates a variable-length string array attribute at a given location
+   * in the file.
    * @param data The string array attribute data.
    * @param path The location in the file to set the attribute.
    * @param name The name of the attribute.
+   * @param overwrite Overwrite the attribute if it already exists.
    * @return The status of the attribute creation operation.
    */
   Status createAttribute(const std::vector<std::string>& data,
                          const std::string& path,
-                         const std::string& name) override;
+                         const std::string& name,
+                         const bool overwrite = false) override;
 
   /**
-   * @brief Creates a string array attribute at a given location in the file.
+   * @brief Creates a fixed-length string array attribute at a given location in
+   * the file.
    * @param data The string array attribute data.
    * @param path The location in the file to set the attribute.
    * @param name The name of the attribute.

src/nwb/RegisteredType.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <filesystem>
 #include <functional>
 #include <memory>
 #include <string>
@@ -68,6 +69,18 @@ class RegisteredType
    */
   inline std::string getPath() const { return m_path; }
 
+  /**
+   * @brief Get the name of the object
+   *
+   * This is the last part of getPath(), much like the filename portion
+   * of a file system path.
+   * @return String with the name of the object
+   */
+  inline std::string getName() const
+  {
+    return std::filesystem::path(m_path).filename().string();
+  }
+
   /**
    * @brief Get a shared pointer to the IO object.
    * @return Shared pointer to the IO object.
@@ -186,14 +199,14 @@ class RegisteredType
   virtual std::string getNamespace() const;
 
   /**
-   * @brief Get the full name of type, i.e., `namespace::typename`
+   * @brief Get the full name of the type, i.e., `namespace::typename`
    *
    * This is just a simple convenience function that uses the getNamespace
    * and getTypeName methods.
    *
    * @return The full name of the type consisting of `namespace::typename`
    */
-  inline std::string getFullName() const
+  inline std::string getFullTypeName() const
   {
     return (getNamespace() + "::" + getTypeName());
   }

src/nwb/base/TimeSeries.cpp

@@ -187,9 +187,5 @@ Status TimeSeries::writeData(const std::vector<SizeType>& dataShape,
         controlShape, controlPositionOffset, this->controlType, controlInput);
   }
 
-  if ((dataStatus != Status::Success) || (tsStatus != Status::Success)) {
-    return Status::Failure;
-  } else {
-    return Status::Success;
-  }
+  return dataStatus && tsStatus;
 }

src/nwb/file/ElectrodeTable.cpp

@@ -12,8 +12,7 @@ REGISTER_SUBCLASS_IMPL(ElectrodeTable)
 /** Constructor */
 ElectrodeTable::ElectrodeTable(std::shared_ptr<IO::BaseIO> io)
     : DynamicTable(electrodeTablePath,  // use the electrodeTablePath
-                   io,
-                   {"group", "group_name", "location"})
+                   io)
     , m_electrodeDataset(std::make_unique<ElementIdentifiers>(
           AQNWB::mergePaths(electrodeTablePath, "id"), io))
     , m_groupNamesDataset(std::make_unique<VectorData>(
@@ -42,30 +41,32 @@ ElectrodeTable::ElectrodeTable(const std::string& path,
 ElectrodeTable::~ElectrodeTable() {}
 
 /** Initialization function*/
-void ElectrodeTable::initialize(const std::string& description)
+Status ElectrodeTable::initialize(const std::string& description)
 {
   // create group
   DynamicTable::initialize(description);
 
-  m_electrodeDataset->initialize(std::unique_ptr<IO::BaseRecordingData>(
-      m_io->createArrayDataSet(IO::BaseDataType::I32,
-                               SizeArray {1},
-                               SizeArray {1},
-                               AQNWB::mergePaths(m_path, "id"))));
-  m_groupNamesDataset->initialize(
+  Status electrodeStatus =
+      m_electrodeDataset->initialize(std::unique_ptr<IO::BaseRecordingData>(
+          m_io->createArrayDataSet(IO::BaseDataType::I32,
+                                   SizeArray {1},
+                                   SizeArray {1},
+                                   AQNWB::mergePaths(m_path, "id"))));
+  Status groupNameStatus = m_groupNamesDataset->initialize(
       std::unique_ptr<IO::BaseRecordingData>(
-          m_io->createArrayDataSet(IO::BaseDataType::STR(250),
+          m_io->createArrayDataSet(IO::BaseDataType::V_STR,
                                    SizeArray {0},
                                    SizeArray {1},
                                    AQNWB::mergePaths(m_path, "group_name"))),
       "the name of the ElectrodeGroup this electrode is a part of");
-  m_locationsDataset->initialize(
+  Status locationStatus = m_locationsDataset->initialize(
       std::unique_ptr<IO::BaseRecordingData>(
-          m_io->createArrayDataSet(IO::BaseDataType::STR(250),
+          m_io->createArrayDataSet(IO::BaseDataType::V_STR,
                                    SizeArray {0},
                                    SizeArray {1},
                                    AQNWB::mergePaths(m_path, "location"))),
       "the location of channel within the subject e.g. brain region");
+  return electrodeStatus && groupNameStatus && locationStatus;
 }
 
 void ElectrodeTable::addElectrodes(std::vector<Channel> channelsInput)
@@ -80,13 +81,16 @@ void ElectrodeTable::addElectrodes(std::vector<Channel> channelsInput)
   }
 }
 
-void ElectrodeTable::finalize()
+Status ElectrodeTable::finalize()
 {
-  setRowIDs(m_electrodeDataset, m_electrodeNumbers);
-  addColumn(m_groupNamesDataset, m_groupNames);
-  addColumn(m_locationsDataset, m_locationNames);
-  addReferenceColumn(
+  Status rowIdStatus = setRowIDs(m_electrodeDataset, m_electrodeNumbers);
+  Status locationColStatus = addColumn(m_locationsDataset, m_locationNames);
+  Status groupColStatus = addReferenceColumn(
       "group",
       "a reference to the ElectrodeGroup this electrode is a part of",
       m_groupReferences);
+  Status groupNameColStatus = addColumn(m_groupNamesDataset, m_groupNames);
+  Status finalizeStatus = DynamicTable::finalize();
+  return rowIdStatus && locationColStatus && groupColStatus
+      && groupNameColStatus && finalizeStatus;
 }

src/nwb/file/ElectrodeTable.hpp

@@ -40,41 +40,27 @@ class ElectrodeTable : public DynamicTable
    * Initializes the ElectrodeTable by creating NWB related attributes and
    * adding required columns.
    *
-   *  @param description The description of the table (default: "metadata about
+   * @param description The description of the table (default: "metadata about
+   * @return Status::Success if successful, otherwise Status::Failure.
    */
-  void initialize(const std::string& description =
-                      "metadata about extracellular electrodes");
+  Status initialize(const std::string& description =
+                        "metadata about extracellular electrodes");
 
   /**
    * @brief Finalizes the ElectrodeTable.
    *
    * Finalizes the ElectrodeTable by adding the required columns and writing
    * the data to the file.
+   * @return Status::Success if successful, otherwise Status::Failure.
    */
-  void finalize();
+  Status finalize();
 
   /**
    * @brief Sets up the ElectrodeTable by adding electrodes and their metadata.
    * @param channelsInput The vector of Channel objects to add to the table.
    */
   void addElectrodes(std::vector<Channel> channelsInput);
 
-  /**
-   * @brief Gets the group path of the ElectrodeTable.
-   * @return The group path.
-   */
-  inline std::string getGroupPath() const
-  {
-    // all channels in ChannelVector should have the same groupName
-    return m_groupReferences[0];
-  }
-
-  /**
-   * @brief Sets the group path of the ElectrodeTable.
-   * @param groupPath The new group path.
-   */
-  void setGroupPath(const std::string& groupPath);
-
   /**
    * @brief The path to the ElectrodeTable.
    */

src/nwb/hdmf/base/Container.cpp

@@ -17,10 +17,11 @@ Container::Container(const std::string& path,
 Container::~Container() {}
 
 /** Initialize */
-void Container::initialize()
+Status Container::initialize()
 {
-  m_io->createGroup(m_path);
+  auto createGroupStatus = m_io->createGroup(m_path);
   // setup common attributes
-  m_io->createCommonNWBAttributes(
+  auto createAttrsStatus = m_io->createCommonNWBAttributes(
       m_path, this->getNamespace(), this->getTypeName());
+  return createGroupStatus && createAttrsStatus;
 }

src/nwb/hdmf/base/Container.hpp

@@ -33,8 +33,9 @@ class Container : public RegisteredType
 
   /**
    * @brief Initialize the container.
+   * @return Status::Success if successful, otherwise Status::Failure.
    */
-  void initialize();
+  Status initialize();
 
   // Define the data fields to expose for lazy read access
   DEFINE_FIELD(readNeurodataType,