wxiobase.h

Go to the documentation of this file.

#ifndef wxiobase_h
#define wxiobase_h
 
// WarpX includes
#include "wxiotmpl.h"
#include "wxexcept.h"
 
#include "lib/wmopaqueptr.h" // TODO: not required here if I move implementation to CC file
 
// std includes
#include <vector>
#include <typeinfo>
#include <list>
#include <string>
#include <exception>
 
class WxIoBase
{
 
public:
    virtual ~WxIoBase();
 
    void setBaseName(const std::string& bn)
    {
        baseName = bn;
    }
 
    std::string getBaseName()
    {
        return baseName;
    }
 
    void setDumpNo(int d)
    {
        dumpNo = d;
    }
 
    int getDumpNo()
    {
        return dumpNo;
    }
 
    virtual WxIoNodeType createFile(const std::string& fileName) = 0;
 
    virtual WxIoNodeType createDumpFile(const std::string& dataName);
 
    virtual WxIoNodeType openFile(const std::string& fileName,
                                  const std::string& perms) = 0;
 
    virtual WxIoNodeType openDumpFile(const std::string& dataName,
                                      const std::string& perms);
 
    virtual void closeFile(WxIoNodeType fileNode) = 0;
 
    virtual std::string getDumpFileName(const std::string& dataName);
 
    virtual WxIoNodeType createGroup(WxIoNodeType node,
                                     const std::string& dataName) const = 0;
 
    virtual WxIoNodeType openGroup(WxIoNodeType node,
                                   const std::string& dataName) const = 0;
 
    virtual std::list<std::string> getGroupNames(WxIoNodeType node) const = 0;
 
    virtual WxIoNodeType createDataSet(WxIoNodeType node,
                                       const std::string& name,
                                       const WxRange& range,
                                       const std::type_info& typeinfo) const = 0;
 
    virtual WxIoNodeType createDataSet(WxIoNodeType node,
                                       const std::string& dataName) const = 0;
 
    virtual WxIoNodeType openDataSet(WxIoNodeType node,
                                     const std::string& dataName) const = 0;
 
    template<typename T>
    WxIoNodeType
    writeDataSet(WxIoNodeType node,
                 const std::string& dataName,
                 const std::vector<std::pair<int, int>>& fileSpaceCorners,
                 const std::vector<std::pair<int, int>>& memorySpaceCorners,
                 const std::vector<std::pair<int, int>>& writeSelectionCorners,
                 const T* data) const
    {
        WmConstOpaquePtr dptr(data);
        return getIoPtr()->writeDataSet(node,
                                        dataName,
                                        fileSpaceCorners,
                                        memorySpaceCorners,
                                        writeSelectionCorners,
                                        dptr);
    }
 
    template<typename T>
    void writeToDataSet(WxIoNodeType node,
                        const WxRange& memoryRange,
                        const WxRange& memorySubRange,
                        const WxRange& fileRange,
                        const WxRange& fileSubRange,
                        const T* data) const
    {
        WmConstOpaquePtr dptr(data);
        getIoPtr()->writeToDataSet(
            node, memoryRange, memorySubRange, fileRange, fileSubRange, dptr);
    }
 
    template<typename T>
    WxIoNodeType readDataSet(WxIoNodeType node,
                             const std::string& dataName,
                             const std::vector<std::pair<int, int>>& memorySpaceCorners,
                             const std::vector<std::pair<int, int>>& readSelectionCorners,
                             T* data) const
    {
        WmOpaquePtr dptr(data);
        return getIoPtr()->readDataSet(
            node, dataName, memorySpaceCorners, readSelectionCorners, dptr);
    }
 
    template<typename T>
    void readFromDataSet(WxIoNodeType node,
                         const WxRange& memoryRange,
                         const WxRange& memorySubRange,
                         const WxRange& fileRange,
                         const WxRange& fileSubRange,
                         T* data) const
    {
        WmOpaquePtr dptr(data);
        getIoPtr()->readFromDataSet(
            node, memoryRange, memorySubRange, fileRange, fileSubRange, dptr);
    }
 
    WxIoNodeType getDataShape(WxIoNodeType node,
                              const std::string& dataSetName,
                              WxRange& dataShape) const
    {
        return getIoPtr()->getDataShape(node, dataSetName, dataShape);
    }
 
    virtual void closeNode(WxIoNodeType node) const = 0;
 
    template<typename T>
    void writeAttribute(WxIoNodeType node, const std::string& attribName, const T* attrib)
    {
        WmConstOpaquePtr aptr(attrib);
        getIoPtr()->writeAttribute(node, attribName, aptr);
    }
 
    template<typename T>
    void writeVecAttribute(WxIoNodeType node,
                           const std::string& attribName,
                           const std::vector<T>& attrib)
    {
        writeVecAttribute<T>(node, attribName, &(attrib[0]), attrib.size());
    }
 
    template<typename T>
    void writeVecAttribute(WxIoNodeType node,
                           const std::string& attribName,
                           const T* attribStorage,
                           int count)
    {
        WmConstOpaquePtr aptr(attribStorage);
        getIoPtr()->writeVecAttribute(node, attribName, aptr, count);
    }
 
    // Characters when meant to represent readable strings are stored a bit differently.
    // TODO: rather than special Str functions, make a specific template implementation at
    // the hdf5 level.
    virtual void writeStrAttribute(WxIoNodeType node,
                                   const std::string& attribName,
                                   const std::string& attrib) const = 0;
 
    virtual void
    writeStrVecAttribute(WxIoNodeType node,
                         const std::string& attribName,
                         const std::vector<std::string>& stringsvector) const = 0;
 
    virtual void readStrAttribute(WxIoNodeType node,
                                  const std::string& attribName,
                                  std::string& attrib) const = 0;
 
    struct AtttributeNotFoundException : std::exception
    {
        const char* what() const noexcept
        {
            return "Attribute Not Found.\n";
        }
    };
 
    virtual std::vector<std::string>
    readStrVecAttribute(WxIoNodeType node, const std::string& attribName) const = 0;
 
    template<typename T>
    void readAttribute(WxIoNodeType node, const std::string& attribName, T* attrib)
    {
        WmOpaquePtr aptr(attrib);
        getIoPtr()->readAttribute(node, attribName, aptr);
    }
 
    template<typename T>
    int readVecAttribute(WxIoNodeType node,
                         const std::string& attribName,
                         T* attribStorage,
                         int count)
    {
        WmOpaquePtr aptr(attribStorage);
        return getIoPtr()->readVecAttribute(node, attribName, aptr, count);
    }
 
protected:
    WxIoBase();
 
    WxIoBase(const std::string& sfx);
 
    WxIoBase(const std::string& bn, int d, const std::string& sfx);
 
    virtual void addOpenFile(WxIoNodeType node);
 
    virtual void removeOpenFile(WxIoNodeType node);
 
    virtual void closeOpenFiles();
 
    void setIo(const WxIoTmpl* b)
    {
        implementationPtr = b;
    }
 
    std::string suffix; // suffix for output
 
private:
    WxIoBase(const WxIoBase&);
 
    WxIoBase& operator=(const WxIoBase&);
 
    const WxIoTmpl* getIoPtr() const
    {
        if (implementationPtr)
            return implementationPtr;
        WxExcept wxe;
        wxe << "I/O implementation not set properly";
        throw wxe;
    }
 
    std::vector<WxIoNodeType> openFiles; // List of all open files
    std::string baseName;                // base name for output
    int dumpNo;                          // dump number
 
    const WxIoTmpl* implementationPtr;
};
 
#endif // wxiobase_h