Empirical
File.h
Go to the documentation of this file.
1 
17 #ifndef EMP_FILE_H
18 #define EMP_FILE_H
19 
20 #include <fstream>
21 #include <functional>
22 #include <iostream>
23 #include <set>
24 #include <string>
25 
26 #include "../base/vector.h"
27 #include "string_utils.h"
28 
29 namespace emp {
30 
32  class File {
33  protected:
35 
36  public:
37  File() : lines() { ; }
38  File(std::istream & input) : lines() { Load(input); }
39  File(const std::string & filename) : lines() { Load(filename); }
40  File(const File &) = default;
41  File(File &&) = default;
42  ~File() { ; }
43 
44  File & operator=(const File &) = default;
45  File & operator=(File &&) = default;
46 
48  auto begin() const { return std::begin(lines); }
49 
51  auto end() const { return std::end(lines); }
52 
54  auto begin() { return std::begin(lines); }
55 
57  auto end() { return std::end(lines); }
58 
60  size_t GetNumLines() const { return lines.size(); }
61 
63  size_t size() const { return lines.size(); }
64 
66  std::string & operator[](size_t pos) { return lines[pos]; }
67 
69  const std::string & operator[](size_t pos) const { return lines[pos]; }
70 
72  std::string & front() { return lines.front(); }
73 
75  const std::string & front() const { return lines.front(); }
76 
78  std::string & back() { return lines.back(); }
79 
81  const std::string & back() const { return lines.back(); }
82 
84  File & Append(const std::string & line) { lines.emplace_back(line); return *this; }
85 
87  File & Append(const emp::vector<std::string> & in_lines) {
88  size_t start_size = lines.size();
89  lines.resize(start_size + in_lines.size());
90  for (size_t pos = 0; pos < in_lines.size(); pos++) {
91  lines[start_size+pos] = in_lines[pos];
92  }
93  return *this;
94  }
95 
97  File & Append(const File & in_file) { return Append(in_file.lines); }
98 
100  template <typename T>
101  File & operator+=(T && in) { Append( std::forward<T>(in) ); return *this; }
102 
105  template <typename T> auto operator<<(T &&in) {
106  Append(std::forward<T>(in));
107  return *this;
108  }
109 
111  auto operator>>(std::string &out) {
112  out = size() ? front() : out;
113  lines.erase(begin());
114  }
115 
117  bool operator==(const File in) { return lines == in.lines; }
118 
120  bool operator!=(const File in) { return lines != in.lines; }
121 
123  File & LoadLine(std::istream & input) {
124  lines.emplace_back("");
125  std::getline(input, lines.back());
126 
127  // If the input file is DOS formatted, make sure to remove the \r at the end of each line.
128  if (lines.back().size() && lines.back().back() == '\r') lines.back().pop_back();
129 
130  return *this;
131  }
132 
134  File & Load(std::istream & input) {
135  while (!input.eof()) {
136  LoadLine(input);
137  }
138  return *this;
139  }
140 
143  File & Load(const std::string & filename) {
144  std::ifstream file(filename);
145  if (file.is_open()) {
146  Load(file);
147  file.close();
148  }
149  return *this;
150  }
151 
153  File & Write(std::ostream & output) {
154  for (std::string & cur_line : lines) {
155  output << cur_line << '\n';
156  }
157  return *this;
158  }
159 
161  File & Write(const std::string & filename) {
162  std::ofstream file(filename);
163  Write(file);
164  file.close();
165  return *this;
166  }
167 
169  std::set<std::string> AsSet() const {
170  std::set<std::string> line_set;
171  for (size_t i = 0; i < lines.size(); i++) {
172  line_set.insert(lines[i]);
173  }
174  return line_set;
175  }
176 
178  File & Apply(const std::function<void(std::string &)> & fun) {
179  for (std::string & cur_line : lines) {
180  fun(cur_line);
181  }
182  return *this;
183  }
184 
186  File & KeepIf(const std::function<bool(const std::string &)> & fun) {
187  emp::vector<std::string> new_lines;
188  for (std::string & cur_line : lines) {
189  if (fun(cur_line)) new_lines.emplace_back(cur_line);
190  }
191  std::swap(lines, new_lines);
192  return *this;
193  }
194 
197  return KeepIf( [](const std::string & str){ return (bool) str.size(); } );
198  }
199 
204  RemoveEmpty();
205  return *this;
206  }
207 
209  File & RemoveWhitespace(bool keep_newlines=true) {
211  RemoveEmpty();
212  if (!keep_newlines) {
213  std::string all_lines;
214  for (const std::string & cur_line : lines){
215  all_lines += cur_line;
216  }
217  lines.resize(1);
218  std::swap(lines[0], all_lines);
219  }
220  return *this;
221  }
222 
224  File & RemoveComments(const std::string & marker) {
225  Apply( [marker](std::string & str) {
226  size_t pos = str.find(marker);
227  if (pos !=std::string::npos) str.resize( pos );
228  } );
229  return *this;
230  }
231 
234  template <typename T>
235  emp::vector<T> Process(const std::function<T(std::string &)> & fun) {
236  emp::vector<T> results(lines.size());
237  for (size_t i = 0; i < lines.size(); i++) {
238  results[i] = fun(lines[i]);
239  }
240  return results;
241  }
242 
244  return Process<std::string>( [delim](std::string & line){
245  return string_pop(line, delim);
246  });
247  }
248 
249  template <typename T>
250  emp::vector<T> ExtractColAs(char delim=',') {
251  return Process<T>( [delim](std::string & line){
252  return emp::from_string<T>(string_pop(line, delim));
253  });
254  }
255  };
256 
257 }
258 
259 #endif
File & Write(const std::string &filename)
Write this file to a file of the provided name.
Definition: File.h:161
File(const std::string &filename)
Definition: File.h:39
static void compress_whitespace(std::string &in_string)
Every time one or more whitespace characters appear replace them with a single space.
Definition: string_utils.h:369
File & Append(const File &in_file)
Join two files.
Definition: File.h:97
File & LoadLine(std::istream &input)
Load a line from an input stream into a file.
Definition: File.h:123
bool operator!=(const File in)
Test if two files are different.
Definition: File.h:120
auto begin() const
Return const iterator to beginning of file.
Definition: File.h:48
static void remove_whitespace(std::string &in_string)
Remove all whitespace from anywhere within a string.
Definition: string_utils.h:392
emp::vector< T > ExtractColAs(char delim=',')
Definition: File.h:250
File & Append(const emp::vector< std::string > &in_lines)
Append a vector of lines to the end of the file.
Definition: File.h:87
const std::string & front() const
Return a const reference to to the first line in the file.
Definition: File.h:75
A class to maintin files for loading, writing, storing, and easy access to components.
Definition: File.h:32
File(std::istream &input)
Definition: File.h:38
const std::string & back() const
Return a const reference to the last line in the file.
Definition: File.h:81
File & KeepIf(const std::function< bool(const std::string &)> &fun)
Purge functions that don&#39;t meet a certain criterion.
Definition: File.h:186
auto operator>>(std::string &out)
Extract first line from file.
Definition: File.h:111
File & Apply(const std::function< void(std::string &)> &fun)
Apply a string manipulation function to all lines in the file.
Definition: File.h:178
Simple functions to manipulate strings.
File & Append(const std::string &line)
Append a new line to the end of the file.
Definition: File.h:84
size_t size() const
Definition: vector.h:151
void emplace_back(ARGS &&...args)
Definition: vector.h:219
emp::vector< T > Process(const std::function< T(std::string &)> &fun)
Definition: File.h:235
File & Write(std::ostream &output)
Write this file to a provided output stream.
Definition: File.h:153
std::string & front()
Return the first line in the file.
Definition: File.h:72
File & Load(std::istream &input)
Load an entire input stream into a file.
Definition: File.h:134
std::string string_pop(std::string &in_string, const char delim=' ')
Definition: string_utils.h:303
size_t GetNumLines() const
How many lines are in this file?
Definition: File.h:60
File & operator=(const File &)=default
auto begin()
Return iterator to beginning of file.
Definition: File.h:54
File()
Definition: File.h:37
File & RemoveEmpty()
Remove all lines that are empty strings.
Definition: File.h:196
const std::string & operator[](size_t pos) const
Const index into a specific line in this file.
Definition: File.h:69
void resize(size_t new_size)
Definition: vector.h:161
auto operator<<(T &&in)
Definition: File.h:105
std::string & back()
Return the last line in the file.
Definition: File.h:78
auto end() const
Return const iterator to end of file.
Definition: File.h:51
File & RemoveComments(const std::string &marker)
A technique to remove all comments in a file.
Definition: File.h:224
size_t size() const
Compatibility with size()
Definition: File.h:63
emp::vector< std::string > ExtractCol(char delim=',')
Definition: File.h:243
auto end()
Return iterator to end of file.
Definition: File.h:57
If we are in emscripten, make sure to include the header.
Definition: array.h:37
File & Load(const std::string &filename)
Definition: File.h:143
std::string & operator[](size_t pos)
Index into a specific line in this file.
Definition: File.h:66
T & back()
Definition: vector.h:183
T & front()
Definition: vector.h:185
~File()
Definition: File.h:42
iterator erase(ARGS &&...args)
Definition: vector.h:207
std::set< std::string > AsSet() const
Convert this file into an std::set of lines (loses line ordering).
Definition: File.h:169
File & RemoveWhitespace(bool keep_newlines=true)
Delete all whitespace; by default keep newlines.
Definition: File.h:209
bool operator==(const File in)
Test if two files are identical.
Definition: File.h:117
File & operator+=(T &&in)
Append to the end of a file.
Definition: File.h:101
File & CompressWhitespace()
Definition: File.h:202
emp::vector< std::string > lines
Definition: File.h:34