file.cpp

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.
 *
 */

#include <ders/file.hpp>
#include <errno.h>
#include <stdio.h>
#include <ders/text_buf.hpp>

namespace ders {  // ::ders

void file::init()
{
 fdr=-1;
 own=false;
 name->clear();
 err=ezero;
}

file::file(mem_pool& m) : mp(m), name(nt(m))
{
 init();
}

file::file(mem_pool& m, const ch_rng& path, mode md, int fls) :
  mp(m), name(nt(m))
{
 init();
 ex_open(path, md, fls);
}

file::file(mem_pool& m, int fd) : mp(m), name(nt(m))
{
 init();
 ex_attach(fd);
}

file::~file()
{
 if (is_owned() && is_opened()) close();
}

bool file::open(const ch_rng& path, mode md, int fls)
{
 assert(!is_opened());

 fdr=fd::open(nt(mp, path)->c_str(), md, fls, err);
 if (fdr==-1) return false;

 own=true;
 *name=path;

 return true;
}

bool file::close()
{
 assert(is_owned());

 bool rc=fd::close(fdr, err);
 if (!rc) return false;

 init();
 return true;
}

bool file::attach(int fd)
{
 assert(!is_opened());

 if (fd<0) {
    err=ebadf;
    return false;
 }

 fdr=fd;
 own=false;
 *name=text_buf(mp)+"(attached to "+fdr+')';
 err=ezero;

 return true;
}

bool file::detach()
{
 assert(is_opened());

 init();
 return true;
}

int file::read(void* buf, int n)
{
 assert(n>=0);

 if (n==0) {
    err=ezero;
    return 0;
 }

 return fd::read(fdr, buf, n, err);
}

int file::read(sh_text& buf, int n)
{
 assert(n>=0);

 buf->clear();
 buf->reserve(n);

 int rc=read(buf->begin(), n);
 assert(rc<=n);
 if (rc!=-1) buf->uninitialized_resize(rc);

 return rc;
}

int file::write(const void* buf, int n)
{
 assert(n>=0);

 if (n==0) {
    err=ezero;
    return 0;
 }

 return fd::write(fdr, buf, n, err);
}

int file::seek(int off, whence wh)
{
 return fd::seek(fdr, off, wh, err);
}

void file::ex_is_ok() const
{
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "File error", get_err(),
      get_name());
 }
}

void file::ex_open(const ch_rng& path, mode md, int fls)
{
 open(path, md, fls);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't open file", get_err(),
      path);
 }
}

void file::ex_close()
{
 close();
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't close file", get_err(),
      get_name());
 }
}

void file::ex_attach(int fd)
{
 attach(fd);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, text_buf(mp)+"Can't attach to \""+
      fd+"\"", get_err(), get_name());
 }
}

void file::ex_detach()
{
 detach();
 if (!is_ok())
    throw newFileErrorException(mp, _FLINE_, "Can't detach", get_err(),
      get_name());
}

int file::ex_read(void* buf, int n)
{
 int rc=read(buf, n);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't read from file", get_err(),
      get_name());
 }

 return rc;
}

int file::ex_read(sh_text& buf, int n)
{
 int rc=read(buf, n);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't read from file", get_err(),
      get_name());
 }

 return rc;
}

int file::ex_write(const void* buf, int n)
{
 int rc=write(buf, n);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't write to file", get_err(),
      get_name());
 }

 return rc;
}

int file::ex_tell()
{
 int rc=tell();
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't tell on file", get_err(),
      get_name());
 }

 return rc;
}

int file::ex_seek(int off, whence wh)
{
 int rc=seek(off, wh);
 if (!is_ok()) {
    throw newFileErrorException(mp, _FLINE_, "Can't seek on file", get_err(),
      get_name());
 }

 return rc;
}

sh_file new_file(mem_pool& mp)
{
 mp_newbuf<file> buf(mp);
 return sh_file(buf.pool(), buf.rls(::new(buf.get()) file(buf.pool())));
}

sh_file new_file(mem_pool& mp, const ch_rng& path, file::mode md, int fls)
{
 mp_newbuf<file> buf(mp);
 return sh_file(buf.pool(), buf.rls(::new(buf.get()) file(buf.pool(), path, md,
   fls)));
}

sh_file new_file(mem_pool& mp, int fd)
{
 mp_newbuf<file> buf(mp);
 return sh_file(buf.pool(), buf.rls(::new(buf.get()) file(buf.pool(), fd)));
}

shException newFileErrorException(mem_pool& mp, const FileLine& loc, const
  ch_rng& msg, error err, const ch_rng& fname)
{
 return newFileErrorException(loc, msg, err, fname, shException(mp, 0));
}

shException newFileErrorException(const FileLine& loc, const ch_rng& msg, error
  err, const ch_rng& fname, shException nest)
{
 mp_newbuf<FileErrorException> buf(nest.pool());
 return shException(buf.pool(), buf.rls(::new(buf.get()) FileErrorException(loc,
   msg, err, fname, nest)));
}

FileErrorException::FileErrorException(const FileLine& loc, const ch_rng& msg,
  error err, const ch_rng& fname, shException nest) :
  ErrorException(loc, msg, err, nest), fileName(nt(nest.pool(), fname))
{
}

sh_text FileErrorException::getClassName() const
{
 return nt(message.pool(), "ders::FileErrorException");
}

sh_text FileErrorException::toText() const
{
 return text_buf(getClassName())+" ["+location.file+":"+location.line+
   "], errorCode="+errorCode+":\""+error_message(message.pool(), errorCode)+
   "\", fileName=\""+fileName+"\", message: "+message;
}

error remove(mem_pool& mp, const ch_rng& fname)
{
 return (::remove(text(mp, fname).c_str())==-1) ? convert_errno(errno) : ezero;
}

void ex_remove(mem_pool& mp, const ch_rng& fname)
{
 error err=remove(mp, fname);
 if (err!=ezero)
    throw newFileErrorException(mp, _FLINE_, "Can't remove file", err, fname);
}

}  // namespace ::ders

---