C++ path::string方法代码示例

bool CrashHandlerImpl::addAttachedFile(const fs::path & file) {
	
	if(file.is_relative()) {
		fs::path absolute = fs::current_path() / file;
		if(absolute.is_relative()) {
			return false;
		}
		return addAttachedFile(absolute);
	}
	
	Autolock autoLock(&m_Lock);

	if(m_pCrashInfo->nbFilesAttached == CrashInfo::MaxNbFiles) {
		LogError << "Too much files already attached to the crash report (" << m_pCrashInfo->nbFilesAttached << ").";
		return false;
	}

	if(file.string().size() >= CrashInfo::MaxFilenameLen) {
		LogError << "File name is too long.";
		return false;
	}

	for(u32 i = 0; i < m_pCrashInfo->nbFilesAttached; i++) {
		if(strcmp(m_pCrashInfo->attachedFiles[i], file.string().c_str()) == 0) {
			LogWarning << "File \"" << file << "\" is already attached.";
			return false;
		}
	}
	
	util::storeStringTerminated(m_pCrashInfo->attachedFiles[m_pCrashInfo->nbFilesAttached], file.string());
	m_pCrashInfo->nbFilesAttached++;

	return true;
}

bool CrashHandlerImpl::addAttachedFile(const fs::path& file) {
	Autolock autoLock(&m_Lock);

	if(m_pCrashInfo->nbFilesAttached == CrashInfo::MaxNbFiles) {
		LogError << "Too much files already attached to the crash report (" << m_pCrashInfo->nbFilesAttached << ").";
		return false;
	}

	if(file.string().size() >= CrashInfo::MaxFilenameLen) {
		LogError << "File name is too long.";
		return false;
	}

	for(int i = 0; i < m_pCrashInfo->nbFilesAttached; i++) {
		if(strcmp(m_pCrashInfo->attachedFiles[i], file.string().c_str()) == 0) {
			LogWarning << "File \"" << file << "\" is already attached.";
			return false;
		}
	}

	strcpy(m_pCrashInfo->attachedFiles[m_pCrashInfo->nbFilesAttached], file.string().c_str());
	m_pCrashInfo->nbFilesAttached++;

	return true;
}

Cursor::Cursor(fs::path imgPath, float hotSpotX, float hotSpotY) {
	sf::Image gif;
	if(!gif.loadFromFile(imgPath.string())) {
		std::string error = "Error loading cursor from " + imgPath.string();
		throw error;
	}
	// Calculate the AND and XOR masks
	HBITMAP cursorAnd = CreateCompatibleBitmap(GetDC(NULL), gif.getSize().x, gif.getSize().y);
	HBITMAP cursorXor = CreateCompatibleBitmap(GetDC(NULL), gif.getSize().x, gif.getSize().y);
	GetMaskBitmaps(gif, cursorAnd, cursorXor);

	ICONINFO iconinfo = {0};
	iconinfo.fIcon = FALSE;
	iconinfo.xHotspot = hotSpotX;
	iconinfo.yHotspot = hotSpotY;
	iconinfo.hbmMask = cursorAnd;
	iconinfo.hbmColor = cursorXor;

	HCURSOR hCursor = CreateIconIndirect(&iconinfo);
	if(hCursor == NULL) {
		std::string error = "Error creating cursor from " + imgPath.string();
		error += " (error code " + std::to_string(GetLastError()) + ")";
		throw error;
	}
	ptr = hCursor;
	DeleteObject(cursorAnd);
	DeleteObject(cursorXor);
}

void
FileSystemTestSetup::setup_clustercache_device(const fs::path& device,
        uint64_t size) const
{
    int fd = ::open(device.string().c_str(),
                    O_RDWR| O_CREAT | O_EXCL,
                    S_IWUSR | S_IRUSR);
    if(fd < 0)
    {
        LOG_ERROR("Couldn't open file " << device << ", " << strerror(errno));
        throw fungi::IOException("Couldn't open file", device.string().c_str());
    }

    BOOST_SCOPE_EXIT((fd))
    {
        ::close(fd);
    }
    BOOST_SCOPE_EXIT_END;

    int ret = ::posix_fallocate(fd, 0, size);
    if (ret != 0)
    {
        LOG_ERROR("Could not allocate file " << device << " with size " << size << ", " << strerror(ret));
        throw fungi::IOException("Could not allocate file",
                                 device.string().c_str(),
                                 ret);
    }

    ::fchmod(fd, 00600);
}

bool CMissionManager::DoCopyFile(const fs::path& source, const fs::path& dest, bool overwrite)
{
	if (overwrite)
	{
		try
		{
			// According to docs, remove() doesn't throw if file doesn't exist
			fs::remove(dest);
			DM_LOG(LC_MAINMENU, LT_INFO)LOGSTRING("Destination file %s already exists, has been removed before copying.\r", dest.string().c_str());
		}
		catch (fs::filesystem_error& e)
		{
			// Don't care about removal error
			DM_LOG(LC_MAINMENU, LT_DEBUG)LOGSTRING("Caught exception while removing destination file %s: %s\r", dest.string().c_str(), e.what());
		}
	}

	// Copy the source file to the destination
	try
	{
		fs::copy_file(source, dest);
		DM_LOG(LC_MAINMENU, LT_INFO)LOGSTRING("File successfully copied to %s.\r", dest.string().c_str());

		return true;
	}
	catch (fs::filesystem_error& e)
	{
		DM_LOG(LC_MAINMENU, LT_ERROR)LOGSTRING("Exception while coyping file from %s to %s: %s\r", 
			source.string().c_str(), dest.string().c_str(), e.what());

		return false;
	}
}

/*******************************************************************
 * Function Name: Save
 * Return Type 	: int
 * Created On	: Nov 10, 2013
 * Created By 	: hrushi
 * Comments		: Save SVM
 * Arguments	: const fs::path fs
 *******************************************************************/
int SVMLearning::Save( const fs::path fs) const
{
	cout << "Writing to: " << fs.string() << endl;

	m_SVM.save(fs.string().c_str());

	return EXIT_SUCCESS;
}

void GstVideoServer::load( const fs::path& path )
{
	CI_LOG_I("Load file: " << path.string()  );
	GstPlayer::load(path.string());
	mCurrentFileName = path.filename().string();
    ///> Now that we have loaded we can grab the pipeline..
    mGstPipeline = GstPlayer::getPipeline();
	setupNetworkClock();
    
}

int remove_hjtremove(fs::path  path, void* data)
{
	if (strstr(path.string().c_str(),".hjtremove") ||
		strstr(path.string().c_str(),".tmp")){
		boost::system::error_code ec;
		fs::remove(path, ec);
		return ec.value();
	}
	return 0;
}

bool RenameOver(fs::path src, fs::path dest)
{
#ifdef WIN32
    return MoveFileExA(src.string().c_str(), dest.string().c_str(),
                       MOVEFILE_REPLACE_EXISTING) != 0;
#else
    int rc = std::rename(src.string().c_str(), dest.string().c_str());
    return (rc == 0);
#endif /* WIN32 */
}

bool MDeepFileIteratorImp::Next(
	fs::path&		outFile)
{
	bool result = false;
	
	while (not result and not mStack.empty())
	{
		struct dirent* e = nil;
		
		MInfo& top = mStack.top();
		
		if (top.mDIR != nil)
			THROW_IF_POSIX_ERROR(::readdir_r(top.mDIR, &top.mEntry, &e));
		
		if (e == nil)
		{
			if (top.mDIR != nil)
				closedir(top.mDIR);
			mStack.pop();
		}
		else
		{
			outFile = top.mParent / e->d_name;
			
			struct stat st;
			if (stat(outFile.string().c_str(), &st) < 0 or S_ISLNK(st.st_mode))
				continue;
			
			if (S_ISDIR(st.st_mode))
			{
				if (strcmp(e->d_name, ".") and strcmp(e->d_name, ".."))
				{
					MInfo info;
	
					info.mParent = outFile;
					info.mDIR = opendir(outFile.string().c_str());
					memset(&info.mEntry, 0, sizeof(info.mEntry));
					
					mStack.push(info);
				}
				continue;
			}

			if (mOnlyTEXT and not IsTEXT(outFile))
				continue;

			if (mFilter.length() and not FileNameMatches(mFilter.c_str(), outFile))
				continue;

			result = true;
		}
	}
	
	return result;
}

TEST_F(FileUtilsTest, copy)
{
    std::string content("content");

    const fs::path a = FileUtils::create_temp_file_in_temp_dir();
    {
        std::ofstream ofs(a.string().c_str());
        ofs << content;
        ofs.close();
    }

    const size_t size = fs::file_size(a);


    const fs::path b = FileUtils::create_temp_file_in_temp_dir("b");
    ASSERT_NO_THROW(fs::remove(b));
    ASSERT_FALSE(fs::exists(b));

    EXPECT_NO_THROW(FileUtils::safe_copy(a, b));
    EXPECT_TRUE(fs::exists(b));
    EXPECT_EQ(size, fs::file_size(b));


    std::string read;
    {
        std::ifstream ifs(b.string().c_str());
        ifs >> read;
        ifs.close();
    }

    EXPECT_EQ(content, read);

    // copy to a larger, existing file
    read = "";
    {
        std::ofstream ofs(a.string().c_str());
        ofs << content << content << content;
        ofs.close();
    }

    EXPECT_LT(size, fs::file_size(a));

    EXPECT_NO_THROW(FileUtils::safe_copy(b, a));

    EXPECT_EQ(size, fs::file_size(a));

    {
        std::ifstream ifs(a.string().c_str());
        ifs >> read;
        ifs.close();
    }

    EXPECT_EQ(content, read);
}

bool CrashHandlerImpl::setReportLocation(const fs::path& location) {
	Autolock autoLock(&m_Lock);

	if(location.string().size() >= CrashInfo::MaxFilenameLen) {
		LogError << "Report location path is too long.";
		return false;
	}

	strcpy(m_pCrashInfo->crashReportFolder, location.string().c_str());

	return true;
}

static void test_parent(const fs::path & in, const std::string & out) {
	
	fs::path p = in.parent();
	arx_assert_msg(p.string() == out, "\"%s\".parent() -> \"%s\" != \"%s\"",
	               in.string().c_str(), p.string().c_str(), out.c_str());
	
	fs::path temp = in;
	temp.up();
	arx_assert_msg(temp.string() == out, "\"%s\".up() ->\"%s\" != \"%s\"",
	               in.string().c_str(), temp.string().c_str(), out.c_str());
	
}

bool FileService::deleteFile(const fs::path& file)
{
  try
  {
    os_chmod(file.string().c_str(), S_IRUSR|S_IWUSR);
    return fs::remove(file);
  }
  catch (const std::exception ex)
  {
    std::cout << "ERROR: delete file " << file.string() << "; exception: " << ex.what() << std::endl;
    return false;
  }
}

void ControleaseApp::loadCanvasFromFile(fs::path file)
{
    console() << "loading patch from: " << file.string() << endl;
    
    if (!exists(file)) {
        console() << "error: cannot find '"<<file.string()<<"'"<<endl;
        return;
    }
    
    // get size of file
    XmlTree xml(loadFile(file));
    
    canvas->initFromXml(xml.getChild("Canvas"));
}