自学教程：C++ FileException函数代码示例

 unsigned long File::FileImpl::Write(const void *buf, unsigned long bytes) {   DWORD WriteBytes = static_cast<DWORD>(bytes);   if (!WriteFile(FileHandle, buf, static_cast<DWORD>(bytes), &WriteBytes, NULL))     throw FileException("Can't write");   return static_cast<unsigned long>(WriteBytes); }

std::string File::readString(size_t len) {	if (!_file)		throw FileException("File is not open");	if ((_mode & FILEMODE_READ) == 0)		throw FileException("Tried to read from file opened in write mode (" + _name.getFullPath() + ")");	std::string s('/0', len);	std::string::iterator is = s.begin();	char c;	while ((c = readByte())) {		*is = c;	}	return s;}

void File::copyFile(const tstring& source, const tstring& target){	if (!::CopyFile(formatPath(source).c_str(), formatPath(target).c_str(), FALSE))	{		throw FileException(Util::translateError(GetLastError())); // 2012-05-03_22-05-14_LZE57W5HZ7NI3VC773UG4DNJ4QIKP7Q7AEBLWOA_AA236F48_crash-stack-r502-beta24-x64-build-9900.dmp	}}

void FileImpl::renameToImpl(const std::string& path){	poco_assert (!_path.empty());	POCO_DESCRIPTOR_STRING(oldNameDsc, _path);	POCO_DESCRIPTOR_STRING(newNameDsc, path);	int res;	if ((res = lib$rename_file(&oldNameDsc, &newNameDsc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) != 1)	{		switch (res & 0x0FFFFFFF)		{		case RMS$_FNF: 			throw FileNotFoundException(_path);		case RMS$_DEV:		case RMS$_DNF:			throw PathNotFoundException(_path);		case RMS$_SYN:			throw PathSyntaxException(path);		case RMS$_RMV:			throw FileAccessDeniedException(_path);		case RMS$_PRV:			throw FileAccessDeniedException("insufficient privileges", _path);				default:			throw FileException(path);		}	}}

/** @brief FileReaderDataSource  *  * @todo: document this function  */ FileReaderDataSource::FileReaderDataSource(std::string FileName){	FileHandle = fopen(FileName.c_str(), "rb");	if (FileHandle == NULL)		throw FileException(std::string("Could not open ") + FileName);	reset();}

utils::File::File(const zchar* const filename, FileAccess access, FileShare share,	FileMode mode, FileType type){	hFile = CreateFileW(filename, static_cast<DWORD>(access), static_cast<DWORD>(share), nullptr,		static_cast<DWORD>(mode), static_cast<DWORD>(type), nullptr);	if (hFile == INVALID_HANDLE_VALUE)	{		OutputDebugStringW(L"Something is wrong:/n");		auto error = GetLastError();		switch (error)		{		case ERROR_FILE_EXISTS:			OutputDebugStringW(L"File already exists./n");			throw FileAlreadyExistsException();		case ERROR_FILE_NOT_FOUND:			OutputDebugStringW(L"File not found./n");			throw FileNotFoundException();		case ERROR_SHARING_VIOLATION:			OutputDebugStringW(L"File cannot be shared./n");			throw FileSharingViolationException();		default:			OutputDebugStringW(L"Reason is not defined./n");			throw FileException();		}	}}

void DirectoryListing::loadFile(const string& name) throw(FileException, SimpleXMLException) {	string txt;	// For now, we detect type by ending...	string ext = Util::getFileExt(name);	if(Util::stricmp(ext, ".bz2") == 0) {		::File ff(name, ::File::READ, ::File::OPEN);		FilteredInputStream<UnBZFilter, false> f(&ff);		const size_t BUF_SIZE = 64*1024;		AutoArray<char> buf(BUF_SIZE);		size_t len;		size_t bytesRead = 0;		for(;;) {			size_t n = BUF_SIZE;			len = f.read(buf, n);			txt.append(buf, len);			bytesRead += len;			if(SETTING(MAX_FILELIST_SIZE) && bytesRead > (size_t)SETTING(MAX_FILELIST_SIZE)*1024*1024)				break;			if(len < BUF_SIZE)				break;		}	} else if(Util::stricmp(ext, ".xml") == 0) {		int64_t sz = ::File::getSize(name);		if(sz == -1 || sz >= static_cast<int64_t>(txt.max_size()))			throw(FileException(CSTRING(FILE_NOT_AVAILABLE)));		txt.resize((size_t) sz);		size_t n = txt.length();		::File(name, ::File::READ, ::File::OPEN).read(&txt[0], n);	}	loadXML(txt, false);}

void SerialChannelImpl::handleError(const std::string& name){	std::string errorText;	DWORD error = GetLastError();	switch (error)	{	case ERROR_FILE_NOT_FOUND:		throw FileNotFoundException(name, getErrorText(errorText));	case ERROR_ACCESS_DENIED:		throw FileAccessDeniedException(name, getErrorText(errorText));	case ERROR_ALREADY_EXISTS:	case ERROR_FILE_EXISTS:		throw FileExistsException(name, getErrorText(errorText));	case ERROR_FILE_READ_ONLY:		throw FileReadOnlyException(name, getErrorText(errorText));	case ERROR_CANNOT_MAKE:	case ERROR_INVALID_NAME:	case ERROR_FILENAME_EXCED_RANGE:		throw CreateFileException(name, getErrorText(errorText));	case ERROR_BROKEN_PIPE:	case ERROR_INVALID_USER_BUFFER:	case ERROR_INSUFFICIENT_BUFFER:		throw IOException(name, getErrorText(errorText));	case ERROR_NOT_ENOUGH_MEMORY:		throw OutOfMemoryException(name, getErrorText(errorText));	case ERROR_HANDLE_EOF: break;	default:		throw FileException(name, getErrorText(errorText));	}}

	GzFileWriter(const std::string &filename) {		file = gzopen(filename.c_str(), "wb9");		if (!file) {			fprintf(stderr, "Can't open file '%s' for writing/n", filename.c_str());			throw FileException();		}	}

void FileImpl::handleLastErrorImpl(const std::string& path){	DWORD err = GetLastError();	switch (err)	{	case ERROR_FILE_NOT_FOUND:		throw FileNotFoundException(path, err);	case ERROR_PATH_NOT_FOUND:	case ERROR_BAD_NETPATH:	case ERROR_CANT_RESOLVE_FILENAME:	case ERROR_INVALID_DRIVE:		throw PathNotFoundException(path, err);	case ERROR_ACCESS_DENIED:		throw FileAccessDeniedException(path, err);	case ERROR_ALREADY_EXISTS:	case ERROR_FILE_EXISTS:		throw FileExistsException(path, err);	case ERROR_INVALID_NAME:	case ERROR_DIRECTORY:	case ERROR_FILENAME_EXCED_RANGE:	case ERROR_BAD_PATHNAME:		throw PathSyntaxException(path, err);	case ERROR_FILE_READ_ONLY:		throw FileReadOnlyException(path, err);	case ERROR_CANNOT_MAKE:		throw CreateFileException(path, err);	case ERROR_DIR_NOT_EMPTY:		throw FileException("directory not empty", path, err);	case ERROR_WRITE_FAULT:		throw WriteFileException(path, err);	case ERROR_READ_FAULT:		throw ReadFileException(path, err);	case ERROR_SHARING_VIOLATION:		throw FileException("sharing violation", path, err);	case ERROR_LOCK_VIOLATION:		throw FileException("lock violation", path, err);	case ERROR_HANDLE_EOF:		throw ReadFileException("EOF reached", path, err);	case ERROR_HANDLE_DISK_FULL:	case ERROR_DISK_FULL:		throw WriteFileException("disk is full", path, err);	case ERROR_NEGATIVE_SEEK:		throw FileException("negative seek", path, err);	default:		throw FileException(path, err);	}}

void File::setEOF(){	dcassert(isOpen());	if (!SetEndOfFile(h))	{		throw FileException(Util::translateError(GetLastError()));	}}

std::size_t FileInputStream::available() const{	long temp = std::ftell(_fp);	if (temp == -1L)		throw FileException();	return _fileSize - temp;}

unsigned intReadableFromZCSV::read(const std::string& string, unsigned int pos, ReadableFromZCSV* data){  pos = data->readFromString(string, pos);  if (static_cast<int>(pos) < 0)    throw FileException(m_fileName, "Failed to read an element.");  return (pos);}

void File::movePos(int64_t pos) throw(FileException){	// [!] IRainman use SetFilePointerEx function!	LARGE_INTEGER x = {0};	x.QuadPart = pos;	if (!::SetFilePointerEx(h, x, &x, FILE_CURRENT))		throw(FileException(Util::translateError(GetLastError()))); //[+]PPA}

void utils::File::Write(const void * data, zuint32 count) const{	zuint32l bytesWritten = 0;	if (!WriteFile(hFile, data, count, &bytesWritten, nullptr))	{		throw FileException();	}}

WP5DefinitionGroup_DefineTablesSubGroup::WP5DefinitionGroup_DefineTablesSubGroup(librevenge::RVNGInputStream *input, WPXEncryption *encryption, unsigned short subGroupSize) :	WP5VariableLengthGroup_SubGroup(),	m_position(0),	m_numColumns(0),	m_leftOffset(0),	m_leftGutter(0),	m_rightGutter(0){	long startPosition = input->tell();	// Skip useless old values to read the old column number	input->seek(2, librevenge::RVNG_SEEK_CUR);	m_numColumns = readU16(input, encryption);	// Skip to new values	input->seek(20+(5*m_numColumns), librevenge::RVNG_SEEK_CUR);	// Read the new values	unsigned char tmpFlags = readU8(input, encryption);	m_position = tmpFlags & 0x07;	input->seek(1, librevenge::RVNG_SEEK_CUR);	m_numColumns = readU16(input, encryption);	input->seek(4, librevenge::RVNG_SEEK_CUR);	m_leftGutter = readU16(input, encryption);	m_rightGutter = readU16(input, encryption);	input->seek(10, librevenge::RVNG_SEEK_CUR);	m_leftOffset = readU16(input, encryption);	int i;	if ((m_numColumns > 32) || ((input->tell() - startPosition + m_numColumns*5) > (subGroupSize - 4)))		throw FileException();	for (i=0; i < m_numColumns; i++)	{		if (input->isEnd())			throw FileException();		m_columnWidth[i] = readU16(input, encryption);	}	for (i=0; i < m_numColumns; i++)	{		if (input->isEnd())			throw FileException();		m_attributeBits[i] = readU16(input, encryption);	}	for (i=0; i < m_numColumns; i++)	{		if (input->isEnd())			throw FileException();		m_columnAlignment[i] = readU8(input, encryption);	}}

////// /brief DeviceManager::OpenDeviceFile Открывает файл устройтсва по заданному имени/// /param fileName Имя файла///void DeviceManager::OpenDeviceFile(const std::string& fileName){    deviceFileDescriptor = open(fileName.c_str(),O_RDWR);    if (deviceFileDescriptor < 0)    {        throw FileException("Error open file: no such file! Kernel module was not loaded!");    }}

std::string File::readString() {	if (!_file)		throw FileException("File is not open");	if ((_mode & FILEMODE_READ) == 0)		throw FileException("Tried to read from file opened in write mode (" + _name.getFullPath() + ")");	std::string s;	try {		char c;		while ((c = readByte())) {			s += c;		}	} catch (FileException &) {		// pass, we reached EOF	}	return s;}

long FileInputStream::getReadPosition() const{	long rVal = ftell(_fp);	if (rVal == -1L)		throw FileException();	return rVal;}

Item::Item(std::string filename) {    std::ifstream fs_item (filename);    if (!fs_item.good()) {        throw FileException("File '" + filename + "' not found or is empty");    }    std::getline(fs_item, name);    std::getline(fs_item, description);    debug_println(BIT6,"Item created from file '" << filename << "' has name set to " << name << " and description set to " << description);}

	void checkTrees() throw(FileException) {		while(cur.getLeaves().size() > verified) {			if(cur.getLeaves().size() > real.getLeaves().size() ||				!(cur.getLeaves()[verified] == real.getLeaves()[verified])) 			{				throw FileException(STRING(TTH_INCONSISTENCY));			}			verified++;		}	}

void utils::File::Seek(zint64 position) const{	zint32 low = position & 0xFFFFFFFF;	zint32l high = position >> 32;	auto result = SetFilePointer(hFile, low, &high, FILE_BEGIN);	if (result == INVALID_SET_FILE_POINTER)	{		throw FileException();	}}

 void File::FileImpl::SeekTo(unsigned long pos) {   if (!pos)   {     SeekToBegin();     return;   }   if (SetFilePointer(FileHandle, static_cast<LONG>(pos), 0, FILE_CURRENT) == INVALID_SET_FILE_POINTER)     throw FileException("Can't seek to mew position"); }

        size_t File::Write(BYTE* in, size_t len)        {            size_t _len = 0;            _len = fwrite(in, sizeof(BYTE), len, m_handle);            if(_len != len)                throw FileException(m_path, errno);                            return _len;        }

        size_t File::Read(BYTE* out, size_t len)        {            size_t _len = 0;            _len = fread(out, sizeof(BYTE), len, m_handle);            if (_len == 0)                throw FileException(m_path, errno);            return _len;        }