pfile.h

Go to the documentation of this file.

/*
 *   P::Classes - Portable C++ Application Framework
 *   Copyright (C) 2000-2004  Christian Prochnow <cproch@seculogix.de>
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _pfile_h_
#define _pfile_h_

#include <pclasses/config.h>
#include <pclasses/pexport.h>
#include <pclasses/pfileinfo.h>
#include <pclasses/piodevice.h>
#include <pclasses/piostream.h>
#include <string>

namespace P {


class PCORE_EXPORT File: public IODevice {
  public:


    enum openMode_t {
      Normal,   
      Append,   
      Truncate  
    };


    enum createMode_t {
      OpenCreate,   
      OpenExisting, 
      CreateFail    
    };

    File() throw();

    File(const File& f) throw(IOError);


    File(const char* path, accessMode_t access, openMode_t open = Normal,
         createMode_t create = OpenCreate, shareMode_t share = AllowNone) throw(IOError);

    ~File() throw();


    void open(const char* path, accessMode_t access, openMode_t open = Normal,
              createMode_t create = OpenCreate, shareMode_t share = AllowNone) throw(IOError);


    size_t peek(char* buffer, size_t count) throw(IOError);

    #ifndef HAVE_LARGEFILE64


    void truncate(off_t size) throw(IOError);

    off_t size() throw(IOError);

    #else


    void truncate(off64_t size) throw(IOError);

    off64_t size() throw(IOError);

    #endif

    void reopen() throw(IOError);

    inline const std::string& path() const throw()
    { return m_path; }

    File& operator=(const File& f) throw(IOError);

    static void unlink(const char* path) throw(IOError);

    static bool exists(const char* path) throw();

    static FileInfo stat(const char* path) throw(IOError);

    static File mktemp(const char* prefix) throw(IOError);

  private:
    std::string   m_path;
    accessMode_t  m_accessMode;
    openMode_t    m_openMode;
    createMode_t  m_createMode;
    shareMode_t   m_shareMode;
};



class PCORE_EXPORT FileStream: public File, public IOStream {
  public:
    FileStream()
    : File(), IOStream(*this, 4096) {}

    FileStream(const char* path, accessMode_t access, openMode_t open = Normal,
               createMode_t create = OpenCreate, shareMode_t share = AllowNone) throw(IOError)
    : File(path, access, open, create), IOStream(*this, 4096) {}

    FileStream(const FileStream& fs) throw(IOError)
    : File(fs), IOStream(*this, 4096) {}

    FileStream(const File& f) throw(IOError)
    : File(f), IOStream(*this, 4096) {}

    ~FileStream() throw()
    {
      try
      {
        close();
      }
      catch(...)
      {
      }
    }

    void close() throw(IOError)
    {
      commit();
      File::close();
    }

    void commit() throw(IOError)
    {
      sync();
      File::commit();
    }

    FileStream& operator=(const FileStream& fs) throw(IOError)
    {
      sync(); flush();
      File::operator=(fs);
      return *this;
    }

};

}

#endif

---