mcl/include/cybozu/file.hpp

#pragma once
/**
	@file
	@brief file class and operations

	@author MITSUNARI Shigeo(@herumi)
	@remark mingw requires -lshlwapi option
*/

#include <assert.h>
#include <sys/stat.h> // for stat
#include <cybozu/exception.hpp>
#include <vector>
#include <ios>
#ifdef _WIN32
	#include <shlwapi.h>
	#include <io.h>
	#include <fcntl.h>
	#include <shlobj.h>
	#include <direct.h>
	#ifndef WIN32_LEAN_AND_MEAN
		#define WIN32_LEAN_AND_MEAN
	#endif
	#include <windows.h>
	#ifdef _MSC_VER
		#pragma comment(lib, "shlwapi.lib")
		#pragma comment(lib, "shell32.lib")
		#pragma comment(lib, "User32.lib")
	#endif
#else
	#include <stdio.h>
	#include <unistd.h>
	#include <sys/types.h>
	#include <fcntl.h>
	#include <dirent.h>
#endif
#ifdef __APPLE__
	#include <mach-o/dyld.h>
#endif

namespace cybozu {

class File {
	std::string name_; // used for only errmsg
#ifdef _WIN32
	typedef HANDLE handleType;
#else
	typedef int handleType;
	enum {
		INVALID_HANDLE_VALUE = -1
	};
#endif
	handleType hdl_;
	bool doClose_;
	bool isReadOnly_;
	File(const File&);
	void operator=(const File&);
#ifdef _WIN32
	void openSub()
	{
	}
#endif
	void verifyMode(std::ios::openmode mode)
	{
		doClose_ = true;
		bool isCorrectMode = true;
		if (!!(mode & std::ios::in) == !!(mode & std::ios::out)) {
			isCorrectMode = false;
		} else {
			if (mode & std::ios::in) {
				isReadOnly_ = true;
				if ((mode & std::ios::app) || (mode & std::ios::trunc)) isCorrectMode = false;
			} else {
				isReadOnly_ = false;
				if ((mode & std::ios::app) && (mode & std::ios::trunc)) isCorrectMode = false;
			}
		}
		if (!isCorrectMode) {
			throw cybozu::Exception("File:open:bad mode") << name_ << mode;
		}
	}
#ifdef _WIN32
	HANDLE createFile(const std::string& name, DWORD access, DWORD share, DWORD disposition)
	{
		return  ::CreateFileA(name.c_str(), access, share, NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL);
	}
	HANDLE createFile(const std::wstring& name, DWORD access, DWORD share, DWORD disposition)
	{
		return  ::CreateFileW(name.c_str(), access, share, NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL);
	}
	template<class T>
	void setHandle(const T& name, std::ios::openmode mode)
	{
		DWORD access = GENERIC_READ;
		DWORD disposition = OPEN_EXISTING;
		DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE;
		if (mode & std::ios::out) {
			access = GENERIC_WRITE;
			disposition = CREATE_ALWAYS;
			if (mode & std::ios::app) {
				disposition = OPEN_ALWAYS;
			}
		}
		hdl_ = createFile(name, access, share, disposition);
	}
#else
	void setHandle(const std::string& name, std::ios::openmode mode)
	{
		int flags = O_RDONLY; // | O_NOATIME; /* can't use on NFS */
		mode_t access = 0644;
		if (mode & std::ios::out) {
			flags = O_WRONLY | O_CREAT;
			if (mode & std::ios::app) {
				flags |= O_APPEND;
			} else {
				flags |= O_TRUNC;
			}
		}
		hdl_ = ::open(name.c_str(), flags, access);
	}
#endif
	template<class T>
	void openSub(const T& name, std::ios::openmode mode)
	{
		if (isOpen()) throw cybozu::Exception("File:open:alread opened") << name_;
		verifyMode(mode);
		setHandle(name, mode);
		if (isOpen()) {
			if (mode & std::ios::app) {
				seek(getSize(), std::ios::beg);
			}
			return;
		}
		throw cybozu::Exception("File:open") << name_ << cybozu::ErrorNo() << static_cast<int>(mode);
	}
public:
	File()
		: hdl_(INVALID_HANDLE_VALUE)
		, doClose_(true)
		, isReadOnly_(false)
	{
	}
	File(const std::string& name, std::ios::openmode mode)
		: hdl_(INVALID_HANDLE_VALUE)
		, doClose_(true)
		, isReadOnly_(false)
	{
		open(name, mode);
	}
	/*
		construct with file handle
		@param hdl [in] file handle
	*/
	explicit File(handleType hdl)
		: hdl_(hdl)
		, doClose_(false)
		, isReadOnly_(false)

	{
	}
	~File() CYBOZU_NOEXCEPT
	{
		if (!doClose_) return;
		try {
			sync();
			close();
		} catch (std::exception& e) {
			fprintf(stderr, "File:dstr:%s\n", e.what());
		} catch (...) {
			fprintf(stderr, "File:dstr:unknown\n");
		}
	}
	bool isOpen() const CYBOZU_NOEXCEPT { return hdl_ != INVALID_HANDLE_VALUE; }
	/**
		support mode
		always binary mode
		ios::in : read only
		ios::out : write only(+truncate)
		ios::out + ios::app(append)
	*/
	void open(const std::string& name, std::ios::openmode mode)
	{
		name_ = name;
		openSub(name, mode);
	}
	void openW(const std::string& name)
	{
		open(name, std::ios::out | std::ios::binary | std::ios::trunc);
	}
	void openR(const std::string& name)
	{
		open(name, std::ios::in | std::ios::binary);
	}
#ifdef _WIN32
	void open(const std::wstring& name, std::ios::openmode mode)
	{
		name_ = cybozu::exception::wstr2str(name);
		openSub(name, mode);
	}
	File(const std::wstring& name, std::ios::openmode mode)
		: hdl_(INVALID_HANDLE_VALUE)
	{
		open(name, mode);
	}
	void openW(const std::wstring& name)
	{
		open(name, std::ios::out | std::ios::binary | std::ios::trunc);
	}
	void openR(const std::wstring& name)
	{
		open(name, std::ios::in | std::ios::binary);
	}
#endif
	void close()
	{
		if (!isOpen()) return;
#ifdef _WIN32
		bool isOK = ::CloseHandle(hdl_) != 0;
#else
		bool isOK = ::close(hdl_) == 0;
#endif
		hdl_ = INVALID_HANDLE_VALUE;
		if (isOK) return;
		throw cybozu::Exception("File:close") << name_ << cybozu::ErrorNo();
	}
	/*
		sync
		@param doFullSync [in] call sync(for only Linux)
	*/
	void sync(bool doFullSync = false)
	{
		cybozu::disable_warning_unused_variable(doFullSync);
		if (!isOpen()) return;
		if (isReadOnly_) return;
#ifdef _WIN32
		/* fail if isReadOnly_ */
		if (!::FlushFileBuffers(hdl_)) goto ERR_EXIT;
#elif defined(__linux__) || defined(__CYGWIN__)
		if (doFullSync) {
			if (::fsync(hdl_)) goto ERR_EXIT;
		} else {
			if (::fdatasync(hdl_)) goto ERR_EXIT;
		}
#else
		if (::fcntl(hdl_, F_FULLFSYNC)) goto ERR_EXIT;
#endif
		return;
	ERR_EXIT:
		throw cybozu::Exception("File:sync") << name_ << cybozu::ErrorNo();
	}
	void write(const void *buf, size_t bufSize)
	{
		const char *p = static_cast<const char *>(buf);
		while (bufSize > 0) {
			uint32_t size = static_cast<uint32_t>(std::min<size_t>(0x7fffffff, bufSize));
#ifdef _WIN32
			DWORD writeSize;
			if (!::WriteFile(hdl_, p, size, &writeSize, NULL)) goto ERR_EXIT;
#else
			ssize_t writeSize = ::write(hdl_, p, size);
			if (writeSize < 0) {
				if (errno == EINTR) continue;
				goto ERR_EXIT;
			}
#endif
			p += writeSize;
			bufSize -= writeSize;
		}
		return;
	ERR_EXIT:
		throw cybozu::Exception("File:write") << name_ << cybozu::ErrorNo();
	}
	size_t readSome(void *buf, size_t bufSize)
	{
		uint32_t size = static_cast<uint32_t>(std::min<size_t>(0x7fffffff, bufSize));
#ifdef _WIN32
		DWORD readSize;
		if (!::ReadFile(hdl_, buf, size, &readSize, NULL)) goto ERR_EXIT;
#else
	RETRY:
		ssize_t readSize = ::read(hdl_, buf, size);
		if (readSize < 0) {
			if (errno == EINTR) goto RETRY;
			goto ERR_EXIT;
		}
#endif
		return readSize;
	ERR_EXIT:
		throw cybozu::Exception("File:read") << name_ << cybozu::ErrorNo();
	}
	void read(void *buf, size_t bufSize)
	{
		char *p = static_cast<char *>(buf);
		while (bufSize > 0) {
			size_t readSize = readSome(p, bufSize);
			p += readSize;
			bufSize -= readSize;
		}
	}
	void seek(int64_t pos, std::ios::seek_dir dir)
	{
#ifdef _WIN32
		LARGE_INTEGER largePos;
		largePos.QuadPart = pos;
		DWORD posMode = FILE_BEGIN;
		switch (dir) {
		case std::ios::beg:
			posMode = FILE_BEGIN;
			break;
		case std::ios::cur:
		default:
			posMode = FILE_CURRENT;
			break;
		case std::ios::end:
			posMode = FILE_END;
			break;
		}
		bool isOK = SetFilePointerEx(hdl_, largePos, NULL, posMode) != 0;
#else
		int whence;
		switch (dir) {
		case std::ios::beg:
			whence = SEEK_SET;
			break;
		case std::ios::cur:
		default:
			whence = SEEK_CUR;
			break;
		case std::ios::end:
			whence = SEEK_END;
			break;
		}
		bool isOK = lseek(hdl_, pos, whence) >= 0;
#endif
		if (isOK) return;
		throw cybozu::Exception("File:seek") << name_ << cybozu::ErrorNo() << pos << static_cast<int>(dir);
	}
	uint64_t getSize() const
	{
		uint64_t fileSize;
#ifdef _WIN32
		LARGE_INTEGER size;
		bool isOK = GetFileSizeEx(hdl_, &size) != 0;
		fileSize = size.QuadPart;
#else
		struct stat stat;
		bool isOK = fstat(hdl_, &stat) == 0;
		fileSize = stat.st_size;
#endif
		if (isOK) return fileSize;
		throw cybozu::Exception("File:getSize") << name_ << cybozu::ErrorNo();
	}
};

/*
	name has extension
*/
inline bool HasExtension(const std::string& name, const std::string& extension)
{
	const size_t extensionSize = extension.size();
	if (extensionSize == 0) return true;
	const size_t nameSize = name.size();
	if (nameSize < extensionSize + 1) return false;
	const char *p = &name[nameSize - extensionSize - 1];
	return *p == '.' && memcmp(p + 1, &extension[0], extensionSize) == 0;
}
/*
	split name as basename.suffix
*/
inline std::string GetBaseName(const std::string& name, std::string *suffix = 0)
{
	size_t pos = name.find_last_of('.');
	if (pos == std::string::npos) {
		if (suffix) suffix->clear();
		return name;
	}
	if (suffix) {
		*suffix = name.substr(pos + 1);
	}
	return name.substr(0, pos);
}

/**
	replace \ with /
*/
inline void ReplaceBackSlash(std::string& str)
{
	for (size_t i = 0, n = str.size(); i < n; i++) {
		if (str[i] == '\\') str[i] = '/';
	}
}

/**
	get exe path and baseNamme
	@note file name is the form "xxx.exe" then baseName = xxx
*/
inline std::string GetExePath(std::string *baseName = 0)
{
	std::string path;
	path.resize(4096);
#ifdef _WIN32
	if (!GetModuleFileNameA(NULL, &path[0], static_cast<int>(path.size()) - 2)) {
		return "";
	}
	PathRemoveExtensionA(&path[0]);
	if (baseName) {
		*baseName = PathFindFileNameA(&path[0]);
	}
	if (::PathRemoveFileSpecA(&path[0])) {
		::PathAddBackslashA(&path[0]);
		path[0] = static_cast<char>(tolower(path[0]));
		path.resize(strlen(&path[0]));
		ReplaceBackSlash(path);
	}
#else
#if defined(__APPLE__)
	uint32_t size = (uint32_t)path.size();
	if (_NSGetExecutablePath(&path[0], &size) != 0) {
		return "";
	}
	path.resize(strlen(&path[0]));
#else
	int ret = readlink("/proc/self/exe", &path[0], path.size() - 2);
	if (ret < 0) return "";
	path.resize(ret);
#endif
	size_t pos = path.find_last_of('/');
	if (pos != std::string::npos) {
		if (baseName) {
			const std::string name = path.substr(pos + 1);
			std::string suffix;
			std::string base = GetBaseName(name, &suffix);
			if (suffix == "exe") {
				*baseName = base;
			} else {
				*baseName = name;
			}
		}
		path.resize(pos + 1);
	}
#endif
	return path;
}

/**
	get file size
*/
inline uint64_t GetFileSize(const std::string& name)
{
#ifdef _WIN32
	struct __stat64 buf;
	bool isOK = _stat64(name.c_str(), &buf) == 0;
#else
	struct stat buf;
	bool isOK = stat(name.c_str(), &buf) == 0;
#endif
	if (isOK) return buf.st_size;
	throw cybozu::Exception("GetFileSize") << name << cybozu::ErrorNo();
}

/**
	verify whether path exists or not
*/
inline bool DoesFileExist(const std::string& path)
{
	if (path.empty()) return false;
	std::string p = path;
	char c = p[p.size() - 1];
	if (c == '/' || c == '\\') {
		p.resize(p.size() - 1);
	}
#ifdef _WIN32
	struct _stat buf;
	return _stat(p.c_str(), &buf) == 0;
#else
	struct stat buf;
	return stat(p.c_str(), &buf) == 0;
#endif
}

inline void RenameFile(const std::string& from, const std::string& to)
{
	if (DoesFileExist(to)) {
		throw cybozu::Exception("RenameFile:file already exist") << from << to;
	}
#ifdef _WIN32
	bool isOK = ::MoveFileExA(from.c_str(), to.c_str(), MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH) != 0;
#else
	bool isOK = ::rename(from.c_str(), to.c_str()) == 0;
#endif
	if (!isOK) {
		throw cybozu::Exception("RenameFile") << from << to << cybozu::ErrorNo();
	}
}

/**
	remove file
*/
inline void RemoveFile(const std::string& name)
{
#ifdef _WIN32
	bool isOK = DeleteFileA(name.c_str()) != 0;
#else
	bool isOK = unlink(name.c_str()) == 0;
#endif
	if (!isOK) {
		throw cybozu::Exception("RemoveFile") << name << cybozu::ErrorNo();
	}
}

/*
	remark of isFile()
	not directory on Windows
	not contain symbolic link on Linux
*/
struct FileInfo {
	std::string name;
	uint32_t attr; // dwFileAttributes for Windows, d_type for Linux
#ifdef _WIN32
	bool isUnknown() const { return attr == 0; }
	bool isDirectory() const { verify(); return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0; }
	bool isFile() const { verify(); return !isDirectory(); }
#else
	bool isUnknown() const { return attr == DT_UNKNOWN; }
	bool isDirectory() const { verify(); return attr == DT_DIR; }
	bool isFile() const { verify(); return attr == DT_REG; }
#endif
	FileInfo() : attr(0) {}
	FileInfo(const std::string& name, uint32_t attr) : name(name), attr(attr) {}
	void verify() const
	{
		if (isUnknown()) throw cybozu::Exception("FileInfo:unknown attr") << name;
	}
};

typedef std::vector<FileInfo> FileList;


namespace file_local {

inline void filterAndPush(FileList& list, const FileInfo& fi, const std::string& extension, bool cond(const std::string&, const std::string&))
{
	if (fi.name == "." || fi.name == "..") {
		return;
	}
	if (cond(fi.name, extension)) {
		list.push_back(fi);
	}
}

} // cybozu::file_local

/**
	get file name in dir
	@param list [out] FileList
	@param dir [in] directory
	@param extension [in] select files(including directory) having extension such as "cpp" ; select all if suffix is empty
	@param cond [in] filter function (select if cond(targetFile, suffix) is true)
	@note "." and ".." are excluded
*/
inline bool GetFileList(FileList &list, const std::string& dir, const std::string& extension = "", bool (*cond)(const std::string&, const std::string&) = cybozu::HasExtension)
{
#ifdef _WIN32
	std::string path = dir + "/*";
	WIN32_FIND_DATAA fd;
	struct Handle {
		Handle(HANDLE hdl)
			: hdl_(hdl)
		{
		}
		~Handle()
		{
			if (hdl_ != INVALID_HANDLE_VALUE) {
				FindClose(hdl_);
			}
		}
		HANDLE hdl_;
	};
	Handle hdl(FindFirstFileA(path.c_str(), &fd));
	if (hdl.hdl_ == INVALID_HANDLE_VALUE) {
		return false;
	}
	do {
		FileInfo fi(fd.cFileName, fd.dwFileAttributes);
		file_local::filterAndPush(list, fi, extension, cond);
	} while (FindNextFileA(hdl.hdl_, &fd) != 0);
	return true;
#else
	struct Handle {
		DIR *dir_;
		Handle(DIR *dir)
			: dir_(dir)
		{
			if (dir_ == 0) {
				perror("opendir");
			}
		}
		~Handle()
		{
			if (dir_) {
				if (::closedir(dir_)) {
					perror("closedir");
				}
			}
		}
		bool isValid() const { return dir_ != 0; }
	};
	Handle hdl(::opendir(dir.c_str()));
	if (!hdl.isValid()) return false;
	for (;;) {
		struct dirent *dp = ::readdir(hdl.dir_);
		if (dp == 0) return true;
		FileInfo fi(dp->d_name, (uint8_t)dp->d_type);
		file_local::filterAndPush(list, fi, extension, cond);
	}
#endif
}

inline FileList GetFileList(const std::string& dir, const std::string& extension = "", bool (*cond)(const std::string&, const std::string&) = cybozu::HasExtension)
{
	FileList fl;
	if (GetFileList(fl, dir, extension, cond)) return fl;
	throw cybozu::Exception("cybozu:GetFileList") << dir << cybozu::ErrorNo();
}

} // cybozu