NeXusFile.hpp

Go to the documentation of this file.

#ifndef NEXUSFILE_HPP
#define NEXUSFILE_HPP 1

#include <map>
#include <string>
#include <utility>
#include <vector>
#include "napi.h"

#ifdef _WIN32

#ifndef _MSC_VER 
#  define NXDLL_EXPORT
#else
#  if IN_NEXUS_CPP_LIBRARY
#    define NXDLL_EXPORT __declspec(dllexport)
#  else
#    define NXDLL_EXPORT __declspec(dllimport)
#  endif
#endif /* _MSC_VER */

#else /* _WIN32 */
#  define NXDLL_EXPORT 
#endif /* _WIN32 */

namespace NeXus {
  enum NXnumtype {
    FLOAT32 = NX_FLOAT32,
    FLOAT64 = NX_FLOAT64,
    INT8 = NX_INT8,
    UINT8 = NX_UINT8,
    // BOOLEAN = NX_BOOLEAN, // NX_BOOLEAN is currently broken
    INT16 = NX_INT16,
    UINT16 = NX_UINT16,
    INT32 = NX_INT32,
    UINT32 = NX_UINT32,
    INT64 = NX_INT64,
    UINT64 = NX_UINT64,
    CHAR = NX_CHAR,
    BINARY = NX_BINARY
  };

  enum NXcompression {
    CHUNK = NX_CHUNK,
    NONE = NX_COMP_NONE,
    LZW = NX_COMP_LZW,
    RLE = NX_COMP_RLE,
    HUF = NX_COMP_HUF
  };

  typedef std::multimap<std::string, std::string> TypeMap;

  struct Info{
    NXnumtype type;
    std::vector<int64_t> dims;
  };

  struct AttrInfo{
    NXnumtype type;
    unsigned length;
    std::string name;
  };

  class NXDLL_EXPORT File
  {
  private:
    NXhandle m_file_id;
    bool m_close_handle;

  public:
    std::pair<std::string, std::string> getNextEntry();
    AttrInfo getNextAttr();

  private:
    void compress(NXcompression comp);

    void initGroupDir();

    void initAttrDir();

    void walkFileForTypeMap(const std::string path, const std::string class_name, TypeMap &tmap);

    const std::string makeCurrentPath(const std::string currpath, const std::string subpath);

    void initOpenFile(const std::string& filename, const NXaccess access = NXACC_READ);

  public:
    File(const std::string& filename, const NXaccess access = NXACC_READ);

    File(const char *filename, const NXaccess access = NXACC_READ);

    File(NXhandle handle, bool close_handle = false);

    ~File();

    void close();

    void flush();

    template<typename NumT>
    void malloc(NumT*& data, const Info& info);

    template<typename NumT>
    void free(NumT*& data);

    void makeGroup(const std::string& name, const std::string& class_name,
                   bool open_group = false);

    void openGroup(const std::string& name, const std::string& class_name);

    void openPath(const std::string& path);

    void openGroupPath(const std::string& path);
    std::string  getPath();

    void closeGroup();

    void makeData(const std::string& name, NXnumtype type,
                  const std::vector<int>& dims, bool open_data = false);

    void makeData(const std::string& name, NXnumtype type,
                  const std::vector<int64_t>& dims, bool open_data = false);

    template <typename NumT>
    void makeData(const std::string& name, const NXnumtype type,
                  const NumT length, bool open_data = false);

    void writeData(const std::string& name, const std::string& value);

    void writeData(const std::string& name, const char* value);

    template <typename NumT>
    void writeData(const std::string& name, const std::vector<NumT>& value);

    template <typename NumT>
    void writeData(const std::string& name, const NumT& value);

    template <typename NumT>
    void writeData(const std::string& name, const std::vector<NumT>& value,
                   const std::vector<int>& dims);

    template <typename NumT>
    void writeData(const std::string& name, const std::vector<NumT>& value,
                   const std::vector<int64_t>& dims);

    template <typename NumT>
    void writeExtendibleData(const std::string& name, std::vector<NumT>& value);

    template <typename NumT>
    void writeExtendibleData(const std::string& name, std::vector<NumT>& value, const int64_t chunk);

    template <typename NumT>
    void writeExtendibleData(const std::string& name, std::vector<NumT>& value,
                             std::vector<int64_t>& dims, std::vector<int64_t> & chunk);


    template <typename NumT>
    void writeUpdatedData(const std::string& name, std::vector<NumT>& value);

    template <typename NumT>
    void writeUpdatedData(const std::string& name, std::vector<NumT>& value,
                          std::vector<int64_t>& dims);

    void makeCompData(const std::string& name, const NXnumtype type,
                      const std::vector<int>& dims, const NXcompression comp,
                      const std::vector<int>& bufsize, bool open_data = false);

    void makeCompData(const std::string& name, const NXnumtype type,
                      const std::vector<int64_t>& dims, const NXcompression comp,
                      const std::vector<int64_t>& bufsize, bool open_data = false);

    template <typename NumT>
    void writeCompData(const std::string & name,
                       const std::vector<NumT> & value,
                       const std::vector<int> & dims, const NXcompression comp,
                       const std::vector<int> & bufsize);

    template <typename NumT>
    void writeCompData(const std::string & name,
                       const std::vector<NumT> & value,
                       const std::vector<int64_t> & dims, const NXcompression comp,
                       const std::vector<int64_t> & bufsize);

    void openData(const std::string& name);

    void closeData();

    void putData(const void* data);

    template <typename NumT>
    void putData(const std::vector<NumT>& data);

    void putAttr(const AttrInfo& info, const void* data);

    template <typename NumT>
    void putAttr(const std::string& name, const NumT value);

    void putAttr(const char* name, const char* value);

    void putAttr(const std::string& name, const std::string value);

    void putSlab(void* data, std::vector<int>& start,
                 std::vector<int>& size);

    void putSlab(void* data, std::vector<int64_t>& start,
                 std::vector<int64_t>& size);

    template <typename NumT>
    void putSlab(std::vector<NumT>& data, std::vector<int>& start,
                 std::vector<int>& size);

    template <typename NumT>
    void putSlab(std::vector<NumT>& data, std::vector<int64_t>& start,
                 std::vector<int64_t>& size);

    template <typename NumT>
    void putSlab(std::vector<NumT>& data, int start, int size);

    template <typename NumT>
    void putSlab(std::vector<NumT>& data, int64_t start, int64_t size);

    NXlink getDataID();

    void makeLink(NXlink& link);

    void makeNamedLink(const std::string& name, NXlink& link);

    void openSourceGroup();

    void getData(void* data);

    template <typename NumT>
    std::vector<NumT> * getData();

    template <typename NumT>
    void getData(std::vector<NumT>& data);

    void getDataCoerce(std::vector<int> &data);

    void getDataCoerce(std::vector<double> &data);

    bool isDataInt();

    template <typename NumT>
    void readData(const std::string & dataName, std::vector<NumT>& data);

    template <typename NumT>
    void readData(const std::string & dataName, NumT & data);

    void readData(const std::string & dataName, std::string & data);

    std::string getStrData();

    Info getInfo();

    std::map<std::string, std::string> getEntries();

    void getEntries(std::map<std::string, std::string> & result);

    void getSlab(void* data, const std::vector<int>& start,
                 const std::vector<int>& size);

    void getSlab(void* data, const std::vector<int64_t>& start,
                 const std::vector<int64_t>& size);

    std::vector<AttrInfo> getAttrInfos();

    bool hasAttr(const std::string & name);

    void getAttr(const AttrInfo& info, void* data, int length = -1);

    template <typename NumT>
    NumT getAttr(const AttrInfo& info);


    template <typename NumT>
        void getAttr(const std::string& name, NumT& value);


    std::string getStrAttr(const AttrInfo & info);

    NXlink getGroupID();

    bool sameID(NXlink& first, NXlink& second);

    void printLink(NXlink & link);

    void setNumberFormat(NXnumtype& type, const std::string& format);

    std::string inquireFile(const int buff_length = NX_MAXPATHLEN);

    std::string isExternalGroup(const std::string& name,
                                const std::string& type,
                                const unsigned buff_length = NX_MAXNAMELEN);

    void linkExternal(const std::string& name, const std::string& type,
                      const std::string& url);
    bool isDataSetOpen();

    TypeMap *getTypeMap();
  };

   template <typename NumT>
     NXDLL_EXPORT NXnumtype getType(NumT number = NumT());


};

#include "NeXusStream.hpp"

#endif