parse.h

// -*-c++-*-
#ifndef STORMM_PARSE_H
#define STORMM_PARSE_H
 
#include <vector>
#include <string>
#include "copyright.h"
#include "Constants/behavior.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "parsing_enumerators.h"
#include "polynumeric.h"
#include "textfile.h"
#include "textguard.h"
 
namespace stormm {
namespace parse {
 
using constants::ExceptionResponse;
using constants::CaseSensitivity;
using data_types::isSignedIntegralScalarType;
using data_types::isUnsignedIntegralScalarType;
using data_types::isFloatingPointScalarType;
  
constexpr int free_number_format = -32788;

std::string operator+(const std::string &lhs, const char4 rhs);
  
std::string char2ToString(const char2 value);
std::string char3ToString(const char3 value);
std::string char4ToString(const char4 value);

char4 stringToChar4(const std::string &value);

std::vector<char4> stringToChar4Vector(const std::string &value, char blank = '\0');

std::string alphabetNumber(ullint input);

std::string rgbHexCode(const uchar4 color_in);
  
bool verifyNumberFormat(const char* a, NumberFormat cform, int read_begin = 0, int len = 0);

bool verifyContents(const char* line, int start_pos, int length,
                    NumberFormat fmt = NumberFormat::CHAR4);
bool verifyContents(const std::string &line, NumberFormat fmt);
bool verifyContents(const std::string &line, int start_pos, int length,
                    NumberFormat fmt = NumberFormat::CHAR4);
bool verifyContents(const TextFile &tf, int line, int start_pos, int length,
                    NumberFormat fmt = NumberFormat::CHAR4);
bool verifyContents(const TextFileReader &tfr, int line, int start_pos, int length,
                    NumberFormat fmt = NumberFormat::CHAR4);

char uppercase(char tc);
char2 uppercase(const char2 tc);
char3 uppercase(const char3 tc);
char4 uppercase(const char4 tc);
std::string uppercase(const std::string &ts);
void uppercase(char* tcs, size_t n_char = 0);
std::string uppercase(const char* tcs);

char lowercase(char tc);
char2 lowercase(const char2 tc);
char3 lowercase(const char3 tc);
char4 lowercase(const char4 tc);
std::string lowercase(const std::string &ts);
void lowercase(char* tcs, size_t n_char = 0);
std::string lowercase(const char* tcs);

bool strcmpCased(const char* sa, const char* sb,
                 const CaseSensitivity csen = CaseSensitivity::YES);
  
bool strcmpCased(const std::string &sa, const char* sb,
                 const CaseSensitivity csen = CaseSensitivity::YES);
 
bool strcmpCased(const char* sa, const std::string &sb,
                 const CaseSensitivity csen = CaseSensitivity::YES);
 
bool strcmpCased(const std::string &sa, const std::string &sb,
                 const CaseSensitivity csen = CaseSensitivity::YES);

bool strncmpCased(const char* sa, const char* sb, int length,
                  CaseSensitivity csen = CaseSensitivity::YES);
 
bool strncmpCased(const std::string &sa, const char* sb,
                  CaseSensitivity csen = CaseSensitivity::YES, int length = -1);
 
bool strncmpCased(const char* sa, const std::string &sb,
                  CaseSensitivity csen = CaseSensitivity::YES, int length = -1);
 
bool strncmpCased(const std::string &sa, const std::string &sb,
                  CaseSensitivity csen = CaseSensitivity::YES, int length = -1);

bool strcmpWildCard(const std::string &target, const std::string &query,
                    const std::vector<WildCardKind> &wildcards);

int realDecimalPlaces(double value, int limit = 10);

std::string addLeadingWhiteSpace(const std::string &input, const size_t target_length);
void addLeadingWhiteSpace(std::string *input, const size_t target_length);

std::string addTailingWhiteSpace(const std::string &input, const size_t target_length);
void addTailingWhiteSpace(std::string *input, const size_t target_length);

std::string removeLeadingWhiteSpace(const std::string &input);
void removeLeadingWhiteSpace(std::string *input);

std::string removeTailingWhiteSpace(const std::string &input);
void removeTailingWhiteSpace(std::string *input);

size_t justifyStrings(std::vector<std::string> *ds, int lower_limit, int upper_limit,
                      JustifyText fside = JustifyText::LEFT, size_t max_length = 10,
                      int long_count = 2, int near_limit = 4);
 
size_t justifyStrings(std::vector<std::string> *ds, JustifyText fside = JustifyText::LEFT,
                      size_t max_length = 10, int long_count = 2, int near_limit = 4);

size_t maximumLineLength(const std::string &input);
  
std::string realToString(double value, int format_a = free_number_format,
                         int format_b = free_number_format,
                         NumberFormat method = NumberFormat::STANDARD_REAL,
                         NumberPrintStyle = NumberPrintStyle::STANDARD);
 
std::string realToString(const double value, const int format_a, const NumberFormat method,
                         const NumberPrintStyle style = NumberPrintStyle::STANDARD);

std::string minimalRealFormat(double value, double rel, bool enforce_decimal = false);

template <typename T>
int findAlignmentWidth(const T* numbers, size_t count, int decimal_places, size_t advance = 1);
 
template <typename T>
int findAlignmentWidth(const std::vector<T> &numbers, int decimal_places, size_t advance = 1);
  
std::string intToString(llint value, int width = free_number_format,
                        NumberPrintStyle = NumberPrintStyle::STANDARD);

const std::vector<TextGuard> operator+(const std::vector<TextGuard> &lhs,
                                       const std::vector<TextGuard> &rhs);

bool detectGuard(const TextFileReader &tfr, const int line_idx, const int pos_idx,
                 const std::string &guard_seq);
 
bool detectGuard(const char* line, const int pos_idx, const std::string &guard_seq);
 
bool detectGuard(const char* line, size_t pos_idx, size_t line_limit,
                 const std::string &guard_seq);

int applyGuard(const char* line, const size_t pos_idx, const size_t line_limit,
               const std::vector<TextGuard> &markers);
 
int applyGuard(const TextFileReader &tfr, const int line_idx, const int pos_idx,
               const std::vector<TextGuard> &markers);

std::vector<bool> markEscapedCharacters(const char* textstr, size_t n_char,
                                        const std::vector<TextGuard> &escapes);
 
std::vector<bool> markEscapedCharacters(const std::string &textstr,
                                        const std::vector<TextGuard> &escapes);
 
std::vector<bool> markEscapedCharacters(const TextFileReader &tfr,
                                        const std::vector<TextGuard> &escapes);

std::vector<bool> markGuardedText(const char* textstr, size_t n_char, const size_t* line_limits,
                                  int line_count, const std::vector<TextGuard> &markers,
                                  const std::vector<TextGuard> &alternatives,
                                  const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<bool> markGuardedText(const char* textstr, const size_t n_char,
                                  const std::vector<TextGuard> &markers,
                                  const std::vector<TextGuard> &alternatives,
                                  const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<bool> markGuardedText(const std::string &str,
                                  const std::vector<TextGuard> &markers,
                                  const std::vector<TextGuard> &alternatives,
                                  const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<bool> markGuardedText(const TextFileReader &tfr,
                                  const std::vector<TextGuard> &markers,
                                  const std::vector<TextGuard> &alternatives,
                                  const std::vector<TextGuard> &escapes = { TextGuard("\\") });

std::vector<int> resolveScopes(const char* input_text, int length,
                               const std::vector<TextGuard> scope_guards,
                               ExceptionResponse policy = ExceptionResponse::DIE);
 
std::vector<int> resolveScopes(const std::string &input_text,
                               const std::vector<TextGuard> scope_guards,
                               ExceptionResponse policy = ExceptionResponse::DIE);

int countDelimiters(const char* text, size_t start_pos, size_t length, const char* delimiters,
                    int ndelim, const std::vector<bool> &quote_mask = {},
                    const std::vector<bool> &comment_mask = {});
 
int countDelimiters(const std::string &text, const std::vector<char> &delimiters,
                    const std::vector<bool> &quote_mask = {},
                    const std::vector<bool> &comment_mask = {});

int countWords(const char* line, const int start_pos, const int length);
int countWords(const std::string &line, const int start_pos, const int length);
int countWords(const TextFile &tf, const int line, const int start_pos, const int length);

void digestText(const char* text, size_t start_pos, size_t length, const char* separators,
                int n_separators, const char* delimiters, int n_delimiters, char* output,
                const std::vector<bool> &quote_mask = {},
                const std::vector<bool> &comment_mask = {},
                std::vector<bool> *output_quoted = nullptr,
                std::vector<bool> *output_commented = nullptr);
 
std::string digestText(const char* text, size_t start_pos, size_t length, const char* separators,
                       int n_separators, const char* delimiters, int n_delimiters,
                       const std::vector<bool> &quote_mask = {},
                       const std::vector<bool> &comment_mask = {},
                       std::vector<bool> *output_quoted = nullptr,
                       std::vector<bool> *output_commented = nullptr);
 
void digestText(const std::string &text, const std::vector<char> &separators,
                const std::vector<char> &delimiters, std::string *output,
                const std::vector<bool> &quote_mask = {},
                const std::vector<bool> &comment_mask = {},
                std::vector<bool> *output_quoted = nullptr,
                std::vector<bool> *output_commented = nullptr);
 
std::string digestText(const std::string &text, const std::vector<char> &separators,
                       const std::vector<char> &delimiters,
                       const std::vector<bool> &quote_mask = {},
                       const std::vector<bool> &comment_mask = {},
                       std::vector<bool> *output_quoted = nullptr,
                       std::vector<bool> *output_commented = nullptr);
  
std::vector<std::string>
separateText(const char* text, int n_char, const std::vector<bool> &comment_mask = {},
             const std::vector<bool> &quotation_mask = {},
             const std::vector<TextGuard> &quote_marks = { TextGuard("\"", "\""),
                                                           TextGuard("'", "'") },
             const std::vector<std::string> &delimiters = {},
             const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<std::string>
separateText(const std::string &text, const std::vector<bool> &comment_mask = {},
             const std::vector<bool> &quotation_mask = {},
             const std::vector<TextGuard> &quote_marks = { TextGuard("\"", "\""),
                                                           TextGuard("'", "'") },
             const std::vector<std::string> &delimiters = {},
             const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<std::string>
separateText(const std::string &text, const std::vector<std::string> &delimiters,
             const std::vector<TextGuard> &escapes = { TextGuard("\\") });
 
std::vector<std::string>
separateText(const TextFile &text, const std::vector<bool> &comment_mask = {},
             const std::vector<bool> &quotation_mask = {},
             const std::vector<TextGuard> &quote_marks = { TextGuard("\"", "\""),
                                                           TextGuard("'", "'") },
             const std::vector<std::string> &delimiters = {},
             const std::vector<TextGuard> &escapes = { TextGuard("\\") });

int findStringInVector(const std::vector<std::string> &vec, const std::string &query);

std::vector<int> vectorStrtol(const std::vector<std::string> &sv,
                              ExceptionResponse policy = ExceptionResponse::DIE);

std::vector<double> vectorStrtod(const std::vector<std::string> &sv,
                                 ExceptionResponse policy = ExceptionResponse::DIE);

std::vector<std::string> vectorOfStrings(const char* v[], int n);
 
std::vector<std::string> vectorOfStrings(const char* s_a, const char* s_b = nullptr,
                                         const char* s_c = nullptr, const char* s_d = nullptr);
 
} // namespace parse
} // namespace stormm
 
#include "parse.tpp"
 
#endif