src/commons/files.h

#ifndef COMMONS_FILES_H
#define COMMONS_FILES_H

#include <exception>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

#include <commons/check.h>

namespace commons
{

  using namespace std;

  class file_not_found_exception : std::exception {
    public:
      file_not_found_exception(const string & name) : name(name) {}
      virtual ~file_not_found_exception() throw() {}
    private:
      const string name;
  };

  void read_file_as_string ( const string & name, string & out ) {
    ifstream in ( name.c_str() );
    if (in.fail()) throw file_not_found_exception( name );
    out = string ( istreambuf_iterator<char> ( in ), istreambuf_iterator<char>() );
  }

  void read_file_as_vector ( const string & name, vector<char> & out ) {
    ifstream in ( name.c_str() );
    if ( in.fail() ) throw file_not_found_exception( name );
    out = vector<char> ( istreambuf_iterator<char> ( in ), istreambuf_iterator<char>() );
  }

  char *
  load_file(const char *path, size_t & len, unsigned int ncpus)
  {
    struct stat sb;
    int fd = checkpass(open(path, 0));

    check0x(fstat(fd, &sb));
    check(sb.st_size <= 0xffffffff);

    // TODO Why don't we need (static) cast here? Isn't this a lossy cast?
    len = sb.st_size;

    char *buf = new char[len + 1];
    checkeqnneg(pread(fd, buf, len, 0), static_cast<ssize_t>(len));

    // TODO Use threads to pull data to the correct initial locations?
    if (false) {
      size_t chunk_len = len / ncpus;
      for (unsigned int i = 0; i < ncpus; i++) {
        size_t off = i * chunk_len;
        size_t nread = static_cast<size_t>
          (checknnegerr(pread(fd, buf + off, chunk_len, off)));
        // We read the whole chunk or hit the end.
        check(nread == chunk_len || off + nread == len);
      }
    }

    check0x(close(fd));

    buf[len] = '\0'; // don't let strcmp() run off the end
    return buf;
  }

}

#endif

---