mdlmol_property.h

// -*-c++-*-
#ifndef STORMM_MOLOBJ_PROPERTY_H
#define STORMM_MOLOBJ_PROPERTY_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Parsing/textfile.h"
#include "molecule_format_enumerators.h"
 
namespace stormm {
namespace structure {
 
using parse::TextFile;
  
class MdlMolProperty {
public:

  MdlMolProperty(const char4 code_in = { ' ', ' ', ' ', ' ' }, int substrate_in = -1,
                 int entry_count_in = 0, int entry_depth_in = 0, bool exclusions_in = false,
                 int substrate_line_pos_in = -1, int entry_count_line_pos_in = -1,
                 int entry_read_start_pos_in = 0,
                 const std::vector<int> &entry_data_bounds_in = {},
                 const std::vector<MolObjPropField> &entry_detail_in = {},
                 const std::vector<MolObjIndexKind> &entry_adjustment_in = {},
                 const std::vector<int> &int_data_in = {},
                 const std::vector<double> &real_data_in = {},
                 const std::vector<std::string> &str_data_in = {},
                 const std::vector<std::string> &data_lines_in = {});
 
  MdlMolProperty(const TextFile &tf, int line_number, int *line_advance,
                 const std::string &title = std::string(""));

  MdlMolProperty(const MdlMolProperty &original) = default;
  MdlMolProperty(MdlMolProperty &&original) = default;
  MdlMolProperty& operator=(const MdlMolProperty &other) = default;
  MdlMolProperty& operator=(MdlMolProperty &&other) = default;
  
  MdlMolPropertyKind getKind() const;

  char4 getCode() const;

  int getSubstrate() const;

  int getPrintedSubstrate() const;

  bool applyToExclusions() const;

  char getExclusionCode() const;
  
  int getEntryCount() const;

  int getDataLineCount() const;
  
  int getIntegerValue(int entry_index, int attribute_index) const;
  int getPrintedIntegerValue(int entry_index, int attribute_index) const;
  double getRealValue(int entry_index, int attribute_index) const;
  char4 getChar4Value(int entry_index, int attribute_index) const;
  std::string getStringValue(int entry_index, int attribute_index) const;

  const std::string& getDataLine(int index) const;

  std::string getMdlText() const;
  
  void setCode(char x, char y, char z, char major = 'M');
 
  void setCode(char4 code_in);

  void setSubstrate(int index);

  void setEntryFormat(const std::vector<MolObjPropField> &entry_detail_in,
                      const std::vector<MolObjIndexKind> &entry_adjustment_in);

  void addEntry(const std::vector <int> &int_data_in, const std::vector <char4> &char4_data_in,
                const std::vector<double> &real_data_in,
                const std::vector<std::string> &str_data_in);
 
private:
  char4 code;               
  MdlMolPropertyKind kind;  
  int substrate;            
  int entry_count;          
  int entry_depth;          
  bool exclusions;          
  int substrate_line_pos;   
  int entry_count_line_pos; 
  int entry_read_start_pos; 

  std::vector<int> entry_data_bounds;
  
  std::vector<MolObjPropField> entry_detail;

  std::vector<MolObjIndexKind> entry_adjustment;
 
  std::vector<int> int_data;                 
  std::vector<double> real_data;             
  std::vector<std::string> str_data;         
  std::vector<std::string> data_lines;       

  bool readEntryCount(const char* line_ptr, int start_pos = 6, int length = 3);

  bool readSubstrateIndex(const char* line_ptr, int start_pos = 7, int length = 3);

  void parseEntries(const TextFile &tf, int line_number, int start_pos,
                    const std::vector<int> &limits);

  void checkAttributeValidity(int entry_index, int attribute_index,
                              MolObjPropField expectation) const;
};
 
} // namespace structure
} // namespace stormm
 
#endif