File.h

/* miktex/Core/File.h:                                  -*- C++ -*-
 
   Copyright (C) 1996-2021 Christian Schenk
 
   This file is part of the MiKTeX Core Library.
 
   The MiKTeX Core Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.
 
   The MiKTeX Core 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with the MiKTeX Core Library; if not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA. */
 
#pragma once
 
#if !defined(BBAFDEB7FCB3409B88E23A547CF822B6)
#define BBAFDEB7FCB3409B88E23A547CF822B6
 
#include <miktex/Core/config.h>
 
#if defined(MIKTEX_WINDOWS)
#include <Windows.h>
#endif
 
#include <cstddef>
#include <cstdio>
#include <ctime>
 
#include <chrono>
#include <fstream>
#include <vector>
 
#include <miktex/Util/OptionSet>
#include <miktex/Util/PathName>
 
#if defined(_MSC_VER)
#pragma warning(push)
// "The compiler encountered a deprecated declaration."
#pragma warning( disable : 4996 )
#endif
 
MIKTEX_CORE_BEGIN_NAMESPACE;
 
enum class FileMode
{
  Append,
  Create,
  CreateNew,
  Open,
  Command
};
 
enum class FileAccess
{
  None,
  Read,
  Write,
  ReadWrite
};
 
enum class FileAttribute
{
  Directory,
  ReadOnly,
#if defined(MIKTEX_WINDOWS)
  Hidden,
#endif
#if defined(MIKTEX_UNIX)
  Executable
#endif
};
 
typedef MiKTeX::Util::OptionSet<FileAttribute> FileAttributeSet;
 
enum class FileOpenOption
{
  None,
  DeleteOnClose
};
 
typedef MiKTeX::Util::OptionSet<FileOpenOption> FileOpenOptionSet;
 
enum class FileDeleteOption
{
  UpdateFndb,
  TryHard,
};
 
typedef MiKTeX::Util::OptionSet<FileDeleteOption> FileDeleteOptionSet;
 
enum class FileMoveOption
{
  UpdateFndb,
  ReplaceExisting,
};
 
typedef MiKTeX::Util::OptionSet<FileMoveOption> FileMoveOptionSet;
 
enum class FileCopyOption
{
  UpdateFndb,
  ReplaceExisting,
  PreserveMode,
};
 
typedef MiKTeX::Util::OptionSet<FileCopyOption> FileCopyOptionSet;
 
enum class CreateLinkOption
{
  UpdateFndb,
  ReplaceExisting,
  Symbolic,
};
 
typedef MiKTeX::Util::OptionSet<CreateLinkOption> CreateLinkOptionSet;
 
enum class FileExistsOption
{
  SymbolicLink
};
 
typedef MiKTeX::Util::OptionSet<FileExistsOption> FileExistsOptionSet;
 
class MIKTEXNOVTABLE File
{
public:
  File() = delete;
 
public:
  File(const File& other) = delete;
 
public:
  File& operator=(const File& other) = delete;
 
public:
  File(File&& other) = delete;
 
public:
  File& operator=(File&& other) = delete;
 
public:
  ~File() = delete;
 
public:
  static MIKTEXCORECEEAPI(void) Delete(const MiKTeX::Util::PathName& path, FileDeleteOptionSet options);
 
public:
  static MIKTEXCORECEEAPI(void) Delete(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(bool) Exists(const MiKTeX::Util::PathName& path, FileExistsOptionSet options);
 
public:
  static MIKTEXCORECEEAPI(bool) Exists(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(FileAttributeSet) GetAttributes(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(unsigned long) GetNativeAttributes(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(std::size_t) GetSize(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(void) Move(const MiKTeX::Util::PathName& source, const MiKTeX::Util::PathName& dest, FileMoveOptionSet option);
 
public:
  static void Move(const MiKTeX::Util::PathName& source, const MiKTeX::Util::PathName& dest)
  {
    Move(source, dest, {});
  }
 
public:
  static MIKTEXCORECEEAPI(void) Copy(const MiKTeX::Util::PathName& source, const MiKTeX::Util::PathName &dest, FileCopyOptionSet options);
 
public:
  static void Copy(const MiKTeX::Util::PathName& source, const MiKTeX::Util::PathName& dest)
  {
    Copy(source, dest, { FileCopyOption::ReplaceExisting });
  }
 
public:
  static MIKTEXCORECEEAPI(void) CreateLink(const MiKTeX::Util::PathName& oldName, const MiKTeX::Util::PathName& newName, CreateLinkOptionSet options);
 
public:
  static MIKTEXCORECEEAPI(bool) IsSymbolicLink(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(MiKTeX::Util::PathName) ReadSymbolicLink(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(bool) Equals(const MiKTeX::Util::PathName& path1, const MiKTeX::Util::PathName& path2);
 
public:
  static MIKTEXCORECEEAPI(size_t) SetMaxOpen(size_t newMax);
 
public:
  static MIKTEXCORECEEAPI(FILE*) Open(const MiKTeX::Util::PathName& path, FileMode mode, FileAccess access);
 
public:
  static MIKTEXCORECEEAPI(FILE*) Open(const MiKTeX::Util::PathName& path, FileMode mode, FileAccess access, bool isTextFile);
 
public:
  static MIKTEXCORECEEAPI(FILE*) Open(const MiKTeX::Util::PathName& path, FileMode mode, FileAccess access, bool isTextFile, FileOpenOptionSet options);
 
public:
  static MIKTEXCORECEEAPI(std::ifstream) CreateInputStream(const MiKTeX::Util::PathName& path, std::ios_base::openmode mode, std::ios_base::iostate exceptions);
 
public:
  static std::ifstream CreateInputStream(const MiKTeX::Util::PathName& path)
  {
    return CreateInputStream(path, std::ios_base::in, std::ios_base::badbit);
  }
 
public:
  static MIKTEXCORECEEAPI(std::ofstream) CreateOutputStream(const MiKTeX::Util::PathName& path, std::ios_base::openmode mode, std::ios_base::iostate exceptions);
 
public:
  static std::ofstream CreateOutputStream(const MiKTeX::Util::PathName& path, std::ios_base::openmode mode)
  {
    return CreateOutputStream(path, mode, std::ios_base::badbit | std::ios_base::failbit);
  }
 
public:
  static std::ofstream CreateOutputStream(const MiKTeX::Util::PathName& path)
  {
    return CreateOutputStream(path, std::ios_base::out, std::ios_base::badbit | std::ios_base::failbit);
  }
 
public:
  static MIKTEXCORECEEAPI(void) SetAttributes(const MiKTeX::Util::PathName& path, FileAttributeSet attributes);
 
public:
  static MIKTEXCORECEEAPI(void) SetNativeAttributes(const MiKTeX::Util::PathName& path, unsigned long nativeAttributes);
 
public:
  static MIKTEXCORECEEAPI(void) SetTimes(int fd, time_t creationTime, time_t lastAccessTime, time_t lastWriteTime);
 
public:
  static MIKTEXCORECEEAPI(void) SetTimes(FILE* file, time_t creationTime, time_t lastAccessTime, time_t lastWriteTime);
 
public:
  static MIKTEXCORECEEAPI(void) SetTimes(const MiKTeX::Util::PathName& path, time_t creationTime, time_t lastAccessTime, time_t lastWriteTime);
 
public:
  static MIKTEXCORECEEAPI(void) GetTimes(const MiKTeX::Util::PathName& path, time_t& creationTime, time_t& lastAccessTime, time_t& lastWriteTime);
 
public:
  static time_t GetLastWriteTime(const MiKTeX::Util::PathName& path)
  {
    time_t creationTime;
    time_t lastAccessTime;
    time_t lastWriteTime;
    GetTimes(path, creationTime, lastAccessTime, lastWriteTime);
    return lastWriteTime;
  }
 
public:
  static MIKTEXCORECEEAPI(std::vector<unsigned char>) ReadAllBytes(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXCORECEEAPI(void) WriteBytes(const MiKTeX::Util::PathName& path, const std::vector<unsigned char>& data);
  
public:
  enum class LockType
  {
    Shared,
    Exclusive
  };
  
public:
  static MIKTEXCORECEEAPI(bool) TryLock(int fd, LockType lockType, std::chrono::milliseconds timeout);
 
public:
  static bool TryLock(FILE* file, LockType lockType, std::chrono::milliseconds timeout)
  {
    return TryLock(fileno(file), lockType, timeout);
  }
 
#if defined(MIKTEX_WINDOWS)
public:
  static MIKTEXCORECEEAPI(bool) TryLock(HANDLE hFile, LockType lockType, std::chrono::milliseconds timeout);
#endif
 
public:
  static MIKTEXCORECEEAPI(void) Unlock(int fd);
 
public:
  static void Unlock(FILE* file)
  {
    Unlock(fileno(file));
  }
 
#if defined(MIKTEX_WINDOWS)
public:
  static MIKTEXCORECEEAPI(void) Unlock(HANDLE hFile);
#endif
};
 
MIKTEX_CORE_END_NAMESPACE;
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
#endif