vectorserie.h

/* Copyright (C) 2009 Markus Friedrich
 *
 * This library is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU Lesser General Public 
 * License as published by the Free Software Foundation; either 
 * version 2.1 of the License, or (at your option) any later version. 
 *  
 * This library is distributed in the hope that it will be useful, 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 * Lesser General Public License for more details. 
 *  
 * You should have received a copy of the GNU Lesser General Public 
 * License along with this library; if not, write to the Free Software 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * Contact:
 *   friedrich.at.gc@googlemail.com
 *
 */
 
#ifndef _HDF5SERIE_VECTORSERIE_H_
#define _HDF5SERIE_VECTORSERIE_H_
 
#include <hdf5serie/interface.h>
#include <hdf5serie/file.h>
#include "hdf5serie/options.h"
#include <vector>
#include <boost/multi_array.hpp>
 
namespace H5 {
 
 
   
  template<class T>
  class VectorSerie : public Dataset {
    friend class Container<Object, GroupBase>;
    private:
      hid_t memDataTypeID; // no need to useScopedHID since only a static hid_t is stored here
      ScopedHID fixedStringTypeID;
      ScopedHID memDataSpaceID;
      ScopedHID memDataSpaceCacheID;
      ScopedHID fileDataSpaceID;
      hsize_t dims[2];
      boost::multi_array<T, 2> cache;
      boost::multi_array<char, 3> cacheFixedSizeStr;
      std::vector<char> bufChar;
      size_t cacheRow;
      void writeToHDF5(size_t nrRows, size_t cacheSize, const std::conditional_t<std::is_same_v<T,std::string>,char,T>* data);
      void openIDandFileDataSpaceID();
    protected:
      VectorSerie(int dummy, GroupBase *parent_, const std::string &name_);
      VectorSerie(GroupBase *parent_, const std::string &name_, int cols, const Options &opts={});
      ~VectorSerie() override;
      void close() override;
      void refresh() override;
      void flush() override;
      void enableSWMR() override;
 
    public:
      void setDescription(const std::string& description);
 
      void append(const T data[], size_t size);
 
      template<class DataType>
      void append(const DataType &data){
        append(&data[0], data.size());
      }
 
      inline int getRows();
 
      inline unsigned int getColumns();
 
      void getRow(int row, size_t size, T data[]);
 
      template<class DataType>
      void getRow(const int row, DataType &data) {
        getRow(row, data.size(), &data[0]);
      }
 
      std::vector<T> getRow(const int row) {
        std::vector<T> data(dims[1]);
        getRow(row, dims[1], &data[0]);
        return data;
      }
 
      void getColumn(int column, size_t size, T data[]);
 
      template<class DataType>
      void getColumn(const int column, DataType &data) {
        getColumn(column, data.size(), &data[0]);
      }
 
      std::vector<T> getColumn(const int row) {
        size_t rows=getRows();
        std::vector<T> data(rows);
        getColumn(row, rows, &data[0]);
        return data;
      }
 
      std::string getDescription();
 
      void setColumnLabel(const std::vector<std::string> &columnLabel);
 
      std::vector<std::string> getColumnLabel();
  };
 
 
 
  // inline definitions
 
  template<class T>
  int VectorSerie<T>::getRows() {
    checkCall(H5Sget_simple_extent_dims(fileDataSpaceID, dims, nullptr));
    return dims[0];
  }
 
  template<class T>
  unsigned int VectorSerie<T>::getColumns() {
    return dims[1];
  }
 
}
 
#endif // _TIMESERIE_H_