Function readFile

c++/src/OrcFile.cc:105–197

  }

  std::unique_ptr<InputStream> readFile(const std::string& path, ReaderMetrics* metrics) {
#ifdef BUILD_LIBHDFSPP
    if (strncmp(path.c_str(), "hdfs://", 7) == 0) {
      return orc::readHdfsFile(std::string(path), metrics);
    } else {
#endif
      return orc::readLocalFile(std::string(path), metrics);
#ifdef BUILD_LIBHDFSPP
    }
#endif
  }

  DIAGNOSTIC_POP

  std::unique_ptr<InputStream> readLocalFile(const std::string& path, ReaderMetrics* metrics) {
    return std::make_unique<FileInputStream>(path, metrics);
  }

  OutputStream::~OutputStream(){
      // PASS
  };

  class FileOutputStream : public OutputStream {
   private:
    std::string filename_;
    int file_;
    uint64_t bytesWritten_;
    bool closed_;

   public:
    FileOutputStream(std::string filename) {
      bytesWritten_ = 0;
      filename_ = filename;
      closed_ = false;
      file_ = open(filename_.c_str(), O_BINARY | O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
      if (file_ == -1) {
        throw ParseError("Can't open " + filename_);
      }
    }

    ~FileOutputStream() override;

    uint64_t getLength() const override {
      return bytesWritten_;
    }

    uint64_t getNaturalWriteSize() const override {
      return 128 * 1024;
    }

    void write(const void* buf, size_t length) override {
      if (closed_) {
        throw std::logic_error("Cannot write to closed stream.");
      }
      ssize_t bytesWrite = ::write(file_, buf, length);
      if (bytesWrite == -1) {
        throw ParseError("Bad write of " + filename_);
      }