namelist_element.h

// -*-c++-*-
#ifndef STORMM_NAMELIST_ELEMENT_H
#define STORMM_NAMELIST_ELEMENT_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Constants/behavior.h"
#include "namelist_enumerators.h"
 
namespace stormm {
namespace namelist {
 
using constants::ExceptionResponse;

class NamelistElement {
public:

  NamelistElement(const std::string &keyword_in, NamelistType kind_in,
                  const std::string &default_in = std::string(""),
                  DefaultIsObligatory obligate = DefaultIsObligatory::NO,
                  InputRepeats rep_in = InputRepeats::NO,
                  const std::string &help_in = std::string("No description provided"));
 
  NamelistElement(const std::string keyword_in, const std::vector<std::string> &sub_keys_in,
                  const std::vector<NamelistType> &sub_kinds_in,
                  const std::vector<std::string> &default_list,
                  DefaultIsObligatory obligate_list = DefaultIsObligatory::NO,
                  InputRepeats rep_in = InputRepeats::NO,
                  const std::string &help_in = std::string("No description provided"),
                  const std::vector<std::string> &sub_help_in =
                  std::vector<std::string>(1, "No description provided"),
                  const std::vector<KeyRequirement> &template_requirements_in = {});

  NamelistElement(const NamelistElement &original) = default;
  NamelistElement(NamelistElement &&original) = default;
  NamelistElement& operator=(const NamelistElement &original) = default;
  NamelistElement& operator=(NamelistElement &&original) = default;
  
  const std::string& getLabel() const;

  const std::string& getSubLabel(size_t index) const;

  NamelistType getKind() const;
  NamelistType getKind(const std::string &sub_key_query) const;

  void setPolicy(ExceptionResponse policy_in);

  void reportNamelistTypeProblem(const std::string &caller, const std::string &data_type) const;

  int getEntryCount() const;

  bool getBoolValue(const std::string &member_key, int index) const;
  bool getBoolValue() const;
  std::vector<bool> getBoolValue(const std::string &member_key) const;
  
  int getIntValue(const std::string &member_key, int index) const;
  int getIntValue(int index) const;
  std::vector<int> getIntValue(const std::string &member_key = std::string("")) const;

  double getRealValue(const std::string &member_key, int index) const;
  double getRealValue(int index) const;
  std::vector<double> getRealValue(const std::string &member_key = std::string("")) const;

  const std::string& getStringValue(const std::string &member_key, int index) const;
  const std::string& getStringValue(int index) const;
  std::vector<std::string> getStringValue(const std::string &member_key = std::string("")) const;

  InputStatus getEstablishment(const std::string &member_key = std::string(""),
                               int repeat_no = 0) const;

  KeyRequirement getImperative() const;
  KeyRequirement getImperative(const std::string &sub_key_query) const;

  bool getRepeatableValueState() const;

  int getTemplateSize() const;

  void badInputResponse(const std::string &errmsg, const char* caller);

  void setDefaultValue(const std::string &modified_default, int default_idx = 0);
  void setDefaultValue(const std::vector<std::string> &modified_defaults,
                       const std::vector<std::string> &sub_key_specs);
  
  void addDefaultValue(const std::string &next_default);

  void activateBool();
  void activateBool(const std::string &su_key_query);
  
  void setIntValue(int value);
  void setIntValue(const std::string &member_key, int value);

  void setRealValue(double value);
  void setRealValue(const std::string &member_key, double value);

  void setStringValue(const std::string &value);
  void setStringValue(const std::string &member_key, const std::string &value);

  void setImperative(const KeyRequirement imperative_in);
  void setImperative(const std::string &sub_key_query, const KeyRequirement imperative_in);
 
private:
  std::string label;                          
  NamelistType kind;                          
  ExceptionResponse policy;                   
  int next_entry_index;                       
   int entry_count;                           
  std::vector<bool> bool_values;              
  std::vector<int> int_values;                
  std::vector<double> real_values;            
  std::vector<std::string> string_values;     
  bool accept_multiple_values;                
  std::string help_message;                   
  std::vector<std::string> sub_keys;          
  std::vector<NamelistType> sub_kinds;        
  std::vector<bool> sub_bool_values;          
  std::vector<int> sub_int_values;            
  std::vector<double> sub_real_values;        
  std::vector<std::string> sub_string_values; 
  std::vector<std::string> sub_help_messages; 
  int template_size;                          
  std::vector<int> template_ints;             
  std::vector<double> template_reals;         
  std::vector<std::string> template_strings;  
 
  // Just as STRUCT-type keywords have the template_(...) arrays to store the default values of
  // their member subkeys, STRING-, INTEGER-, and REAL-type keywords have special storage for their
  // default(s).  The default value for any BOOL member of a struct, and any BOOL keyword in
  // general, is FALSE.
  std::vector<int> default_int_values;             
  std::vector<double> default_real_values;         
  std::vector<std::string> default_string_values;  
  
  InputStatus establishment;     

  KeyRequirement imperative;
  
  std::vector<InputStatus> template_establishment;

  std::vector<KeyRequirement> template_requirements;
  
  std::vector<InputStatus> instance_establishment;

  std::vector<bool> sub_key_found;

  bool defaultIsMissing(const std::string &default_input) const;

  std::vector<InputStatus> setEstablishment(const std::vector<std::string> &list_of_defaults);

  int validateSubKey(const std::string &sub_key_query, NamelistType nmlt,
                     const std::string &caller) const;

  void resizeBuffer();
 
  // The namelist emulator is a friend, so that excessive copying doesn't have to happen just
  // to search and access data
  friend struct NamelistEmulator;
};
 
} // namespace namelist
} // namespace stormm
 
#endif