textfile.h

// -*-c++-*-
#ifndef STORMM_TEXTFILE_H
#define STORMM_TEXTFILE_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "DataTypes/stormm_vector_types.h"
#include "FileManagement/file_enumerators.h"
#include "Reporting/reporting_enumerators.h"
#include "parsing_enumerators.h"
 
namespace stormm {
namespace parse {
 
using diskutil::PrintSituation;
using review::TextEnds;

struct TextFileReader {

  TextFileReader(int line_count_in, const int* line_lengths_in, const size_t* line_limits_in,
                 const char* text_in, const std::string file_name_in);

  TextFileReader(const TextFileReader &original) = default;
  TextFileReader(TextFileReader &&original) = default;
 
  const int line_count;
  const int* line_lengths;
  const size_t* line_limits;
  const char* text;
  const std::string file_name;
};
  
class TextFile {
public:

  TextFile();
 
  TextFile(const std::string &file_name, TextOrigin source = TextOrigin::DISK,
           const std::string &content = std::string(""),
           const std::string &caller = std::string(""));
 
  TextFile(const char* content, const size_t length, const std::string &caller = std::string(""));

  TextFile(const TextFile &original) = default;
  TextFile(TextFile &&original) = default;
  TextFile& operator=(const TextFile &other) = default;
  TextFile& operator=(TextFile &&other) = default;
  
  ~TextFile() = default;

  std::string getFileName() const;

  int getLineCount() const;

  int getLineLimits(int index) const;

  int getLineLength(int index) const;

  int getLongestLineLength() const;

  size_t getTextSize() const;
  
  char getChar(int index) const;

  std::string getLineAsString(int line_index) const;
  
  const char* getTextPointer(int index) const;

  const char* getLinePointer(int line_index) const;
  
  const TextFileReader data() const;

  std::string extractString(int line_number, int start_pos = 0, int string_length = -1) const;

  char4 extractChar4(int line_number, int start_pos, int string_length) const;

  std::string toString(TextEnds line_endings = TextEnds::NEWLINE) const;

  void write(std::ofstream *foutp) const;
  void write(const std::string &new_filename,
             PrintSituation expectation = PrintSituation::OPEN_NEW) const;
  void write(PrintSituation expectation = PrintSituation::OPEN_NEW) const;
  
private:

  std::string orig_file;

  int line_count;

  std::vector<int> line_lengths;
  
  std::vector<size_t> line_limits;
  
  std::vector<char> text;

  void validateLineIndex(int index, const char* caller) const;
  
  std::string setFileName(const std::string &file_name, TextOrigin source,
                          const std::string &content);

  void linesFromString(const char* text_in, const size_t n_char);
  void linesFromString(const std::string &text_in);
  
  int checkAvailableLength(int line_number, int start_pos = 0, int string_length = -1) const;
};
 
} // namespace parse
} // namespace stormm
 
#endif