File.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_File_hxx
#define __ccxx_File_hxx

#include <commonc++/Common.h++>
#include <commonc++/FileName.h++>
#include <commonc++/Permissions.h++>
#include <commonc++/Stream.h++>
#include <commonc++/String.h++>

namespace ccxx {

enum FileType {
  TypeFile,
  TypeDir,
  TypeSymLink,
  TypePipe,
  TypeDevice,
  TypeOther,
  TypeUnknown
};

enum FileOpenMode {
  FileOpenElseCreate,
  FileOpen,
  FileCreate,
  FileTruncate,
  FileTruncateElseCreate
};

struct COMMONCPP_API FileAttributes
{
  FileAttributes()
    : type(TypeUnknown),
      created(INT64_CONST(0)),
      modified(INT64_CONST(0)),
      accessed(INT64_CONST(0)),
      size(UINT64_CONST(0))
  { }

  FileType type;
  time_ms_t created;
  time_ms_t modified;
  time_ms_t accessed;
  uint64_t size;
  Permissions permissions;

  inline bool isDirectory() const
  { return(type == TypeDir); }

  inline bool isFile() const
  { return(type == TypeFile); }
};

enum LockType {
  LockRead,
  LockWrite
};

class COMMONCPP_API File : public Stream
{
 public:

  File(const String& path);

  virtual ~File();

  void open(IOMode mode = IOReadWrite,
            FileOpenMode openMode = FileOpenElseCreate,
            const Permissions& perm = Permissions::USER_READ_WRITE);

  bool exists() const;

  bool isDirectory() const;

  bool isFile() const;

  bool isPipe() const;

  bool isSymLink() const;

  bool touch();

  bool remove();

  bool setPermissions(const Permissions& perm);

  bool getPermissions(Permissions& perm);

  bool lockRange(uint64_t start, uint64_t length, LockType type,
                 bool wait = true);

  bool unlockRange(uint64_t start, uint64_t length);

  void truncate(uint64_t size = 0);

  inline String getPath() const
  { return(_name); }

  int64_t getSize();

  static bool makeDirectory(
    const String& path, bool createAll = false,
    const Permissions& perm = Permissions::defaultDirPerms);

  static bool remove(const String& path);

  static bool removeDirectory(const String& path);

  static bool removeDirectoryTree(const String& path);

  static bool exists(const String& path);

  static bool isDirectory(const String& path);

  static bool isFile(const String& path);

  static bool isPipe(const String& path);

  static bool isSymLink(const String& path);

  static bool readSymLink(String& path);

  static bool resolveSymLink(String& path);

  static bool createLink(const String& oldPath, const String& newPath,
                         bool hardLink = false);

  static bool setPermissions(const String& path, const Permissions& perm);

  static bool getPermissions(const String& path, Permissions& perm);

  static bool getAttributes(const String& path, FileAttributes& attrs);

  static int64_t getSize(const String& path);

  static bool rename(const String& oldName, const String& newName);

  static bool copy(const String& oldFile, const String& newFile);

  static bool move(const String& oldFile, const String& newFile);

  static bool touch(const String& path);

  static String readToString(const String& path);

  static void getFileSystemRoots(StringVec& roots, bool localOnly = true);

  static void setCreationMask(const Permissions& perm);

  static uint64_t getDiskFreeSpace(const String& path);

  static size_t getDiskBlockSize(const String& path);

  static int64_t roundSizeToBlockSize(const int64_t& fileSize,
                                      size_t blockSize);

  static String removeTrailingSeparators(const String& path);

  static const char separator;

  static const char validSeparators[];

  static bool isValidSeparator(char c);

  static bool isValidSeparator(char16_t c);

  static const char separatorString[];

  static const char* eol;

 protected:

  String _name;

 private:

  CCXX_COPY_DECLS(File);
};

} // namespace ccxx

#endif // __ccxx_File_hxx