binary_encoding.h

// -*-c++-*-
#ifndef STORMM_BINARY_ENCODING_H
#define STORMM_BINARY_ENCODING_H
 
#include <cstdint>
#include <string>
#include <vector>
#include "copyright.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "Trajectory/phasespace.h"
 
namespace stormm {
namespace diskutil {
 
using card::Hybrid;
using card::HybridTargetLevel;
using synthesis::PhaseSpaceSynthesis;
using trajectory::CoordinateFrame;
using trajectory::CoordinateFrameReader;
using trajectory::CoordinateSeries;
using trajectory::PhaseSpace;

const char default_binary_file_descriptor[] = "No description provided";
const char default_cf_descriptor[] = "CoordinateFrame with positions";
const char default_ps_descriptor[] = "PhaseSpace with positions and velocities";
const char default_cs_descriptor[] = "CoordinateSeries with positions";
const char default_polyps_descriptor[] = "PhaseSpaceSynthesis with positions";
  
class BinaryFileContent {
public:

  template <typename T>
  BinaryFileContent(T content_in, bool repeating_in, const std::string description_in,
                    HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileContent(size_t ct_vptr_in, size_t length_in, const void* vptr_in, bool repeating_in,
                    const std::string &description_in,
                    HybridTargetLevel tier_in = HybridTargetLevel::HOST);

  void setLowerBound(llint lower_bound_in);

  void setUpperBound(llint upper_bound_in);
  
private:
  size_t ct_vptr;           
  uint16_t type_code;       
  size_t length;            
  std::string description;  
  void* vptr;               
  HybridTargetLevel tier;   
  llint lower_bound;        
  llint upper_bound;        
};

class BinaryFileKey {
public:

  BinaryFileKey(const std::string &description_in = std::string(""));
  
  template <typename T> BinaryFileKey(const T* content, size_t length,
                                      const std::string &description_in = std::string(""),
                                      HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T> BinaryFileKey(const std::vector<T> *content,
                                      const std::string &description_in = std::string(""));
 
  template <typename T> BinaryFileKey(const std::vector<T> &content,
                                      const std::string &description_in = std::string(""));
 
  template <typename T> BinaryFileKey(const Hybrid<T> *content,
                                      const std::string &description_in = std::string(""),
                                      HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T> BinaryFileKey(const Hybrid<T> &content,
                                      const std::string &description_in = std::string(""),
                                      HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const CoordinateFrame *cf,
                const std::string &description_in = std::string(default_cf_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const CoordinateFrame &cf,
                const std::string &description_in = std::string(default_cf_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const PhaseSpace *ps,
                const std::string &description_in = std::string(default_ps_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const PhaseSpace &ps,
                const std::string &description_in = std::string(default_ps_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T>
  BinaryFileKey(const CoordinateSeries<T> *content,
                const std::string &description_in = std::string(default_cs_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T>
  BinaryFileKey(const CoordinateSeries<T> &content,
                const std::string &description_in = std::string(default_cs_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const PhaseSpaceSynthesis *content,
                const std::string &description_in = std::string(default_polyps_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  BinaryFileKey(const PhaseSpaceSynthesis &content,
                const std::string &description_in = std::string(default_polyps_descriptor),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);

  void addArray(const void *vptr, size_t length, size_t ct_vptr, bool repeating_in,
                const std::string &description_in = std::string(""),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T>
  void addArray(const T* content, size_t length, bool repeating_in,
                const std::string &description_in,
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
  
  template <typename T>
  void addArray(const std::vector<T> *content, bool repeating_in,
                const std::string &description_in = std::string(""));
 
  template <typename T>
  void addArray(const std::vector<T> &content, bool repeating_in,
                const std::string &description_in = std::string(""));
 
  template <typename T>
  void addArray(const Hybrid<T> *content, bool repeating_in,
                const std::string &description_in = std::string(""),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);
 
  template <typename T>
  void addArray(const Hybrid<T> &content, bool repeating_in,
                const std::string &description_in = std::string(""),
                HybridTargetLevel tier_in = HybridTargetLevel::HOST);

  template <typename T> void addScalar(T parm,
                                       const std::string &description_in = std::string(""));

  template <typename T2> void addTuple2(T2 parm,
                                        const std::string &description_in = std::string(""));

  template <typename T3> void addTuple3(T3 parm,
                                        const std::string &description_in = std::string(""));

  template <typename T4> void addTuple4(T4 parm,
                                        const std::string &description_in = std::string(""));
 
private:
  std::string description;                         
  std::vector<char> tiers;                         
  std::vector<BinaryFileContent> singleton_items;  
  std::vector<BinaryFileContent> array_items;      
  size_t stride;                                   
  size_t toc_bytes;                                
  size_t nonrepeating_bytes;                       
  llint total_expected_bytes;                      
  llint total_written_bytes;                       
  llint toc_checksum;                              
  llint content_checksum;                          
  TrajectoryCompression packed_format;             
};

char codifyHybridTargetLevel(HybridTargetLevel tier);
  
uint16_t codifyTypeIndex(size_t ct, bool is_array, bool is_repeatable);
  
} // namespace diskutil
} // namespace stormm
 
#include "binary_encoding.tpp"
 
#endif