file.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008-2009.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#ifndef __DERS__FILE_HPP__
#define __DERS__FILE_HPP__

#include <ders/config.hpp>
#include <ders/buf_rdwr.hpp>
#include <ders/error.hpp>

namespace ders {  // ::ders

class file : public readable, public writable {
 public:
      enum mode { rdo, wro, rdwr };
      enum flags { app=1, crt=2, excl=4, trnc=8 };
      enum whence { set, cur, end };

 private:
      mem_pool& mp;
      int fdr;
      bool own;
      sh_text name;
      error err;

      void init();

      file(const file&);
      file& operator=(const file&);

 public:
      file(mem_pool& m);
      file(mem_pool& m, const ch_rng& path, mode md, int fls);
      file(mem_pool& m, int fd);
      ~file();

      virtual void destroy(mem_pool& mp2) { destroy_this(this, mp2); }

      mem_pool& pool() const { return mp; }

      bool is_ok() const { return get_err()==ezero; }
      bool is_opened() const { return get_fd()!=-1; }
      bool is_owned() const { return own; }

      int get_fd() const { return fdr; }
      const sh_text& get_name() const { return name; }
      error get_err() const { return err; }

      bool open(const ch_rng& path, mode md, int fls);
      bool close();

      bool attach(int fd);
      bool detach();

      virtual int read(void* buf, int n);
      int read(sh_text& buf, int n);

      virtual int write(const void* buf, int n);
      int write(const ch_rng& r) { return write(r.beg, r.size()); }

      int tell() { return seek(0, cur); }
      int seek(int off, whence wh);

      void ex_is_ok() const;
      void ex_open(const ch_rng& path, mode md, int fls);
      void ex_close();
      void ex_attach(int fd);
      void ex_detach();
      int ex_read(void* buf, int n);
      int ex_read(sh_text& buf, int n);
      int ex_write(const void* buf, int n);
      int ex_write(const ch_rng& r) { return ex_write(r.beg, r.size()); }
      int ex_tell();
      int ex_seek(int off, whence wh);
};

typedef sh_ptr<file> sh_file;

sh_file new_file(mem_pool& mp);

sh_file new_file(mem_pool& mp, const ch_rng& path, file::mode md, int fls);

sh_file new_file(mem_pool& mp, int fd);

shException newFileErrorException(mem_pool& mp, const FileLine& loc, const
  ch_rng& msg, error err, const ch_rng& fname);
shException newFileErrorException(const FileLine& loc, const ch_rng& msg, error
  err, const ch_rng& fname, shException nest);

class FileErrorException : public ErrorException {
      friend shException newFileErrorException(const FileLine& loc, const
        ch_rng& msg, error err, const ch_rng& fname, shException nest);

      FileErrorException(const FileErrorException&);
      FileErrorException& operator=(const FileErrorException&);

 protected:
      FileErrorException(const FileLine& loc, const ch_rng& msg, error err,
        const ch_rng& fname, shException nest);

 public:
      const sh_text fileName;

      virtual sh_text getClassName() const;
      virtual sh_text toText() const;

      virtual void destroy(mem_pool& mp2) { destroy_this(this, mp2); }
};

error remove(mem_pool& mp, const ch_rng& fname);
void ex_remove(mem_pool& mp, const ch_rng& fname);

class fd {
      fd();

 public:
      static const int in =0;
      static const int out=1;
      static const int err=2;

      static int open(const char* path, file::mode md, int fls, error& err);
      static bool close(int fd, error& err);

      static int read(int fd, void* buf, int n, error& err);
      static int write(int fd, const void* buf, int n, error& err);

      static int seek(int fd, int off, file::whence wh, error& err);
};

}  // namespace ::ders

#endif  // __DERS__FILE_HPP__

---