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

	bool Taskbar::CreateOrUpdate(fs::path const& target_path) 
	{
		try
		{
			if (base::win::version() >= base::win::VERSION_WIN7)
			{
				fs::path shortcut_path = base::path::get(base::path::DIR_TEMP) / target_path.filename().replace_extension(L".lnk");

				if (!detail::CreateOrUpdateShortcutLink(shortcut_path, target_path))
				{
					throw std::domain_error(("Couldn't create or update shortcut at " + shortcut_path.string()).c_str());
				}

				bool result = detail::TaskbarPinShortcutLink(shortcut_path);
				fs::remove(shortcut_path);
				return result;
			}
			else
			{
				fs::path shortcut_path = base::path::get(base::path::DIR_USER_QUICK_LAUNCH) / target_path.filename().replace_extension(L".lnk");

				return detail::CreateOrUpdateShortcutLink(shortcut_path, target_path);
			}
		}
		catch (...)
		{
		}

		return false;
	}

	bool Taskbar::CreateOrUpdate(fs::path const& target_path) 
	{
		try
		{
			if (bee::platform::get_version().ver >= bee::platform::WinVer::Win10)
			{
			}
			else if (bee::platform::get_version().ver >= bee::platform::WinVer::Win7)
			{
				fs::path shortcut_path = fs::temp_directory_path() / target_path.filename().replace_extension(L".lnk");

				if (!detail::CreateOrUpdateShortcutLink(shortcut_path, target_path))
				{
					throw std::domain_error(("Couldn't create or update shortcut at " + shortcut_path.string()).c_str());
				}

				bool result = detail::TaskbarPinShortcutLink(shortcut_path);
				fs::remove(shortcut_path);
				return result;
			}
			else
			{
				fs::path shortcut_path = detail::quick_launch_path() / target_path.filename().replace_extension(L".lnk");

				return detail::CreateOrUpdateShortcutLink(shortcut_path, target_path);
			}
		}
		catch (...)
		{
		}

		return false;
	}

void ocvOpticalFlowApp::loadMovieFile( const fs::path &moviePath )
{
	try {
		// load up the movie, set it to loop, and begin playing
    	mMovie = qtime::MovieSurface( moviePath );    
		mMovie.setLoop();
		mMovie.play();
		
		// create a texture for showing some info about the movie
		TextLayout infoText;
		infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
		infoText.setColor( Color::white() );
		infoText.addCenteredLine( moviePath.filename().string() );
		infoText.addLine( toString( mMovie.getWidth() ) + " x " + toString( mMovie.getHeight() ) + " pixels" );
		infoText.addLine( toString( mMovie.getDuration() ) + " seconds" );
		infoText.addLine( toString( mMovie.getNumFrames() ) + " frames" );
		infoText.addLine( toString( mMovie.getFramerate() ) + " fps" );
		infoText.setBorder( 4, 2 );
		mInfoTexture = gl::Texture( infoText.render( true ) );
	}
	catch( ... ) {
		console() << "Unable to load the movie." << std::endl;
		mMovie.reset();
		mInfoTexture.reset();
	}
    
	mFrameTexture.reset();
}

void trm::Database::createEntry(fs::path path, fs::path trashPath, std::size_t size)
{
    sqlite3_stmt *stmt;
    std::string objectName = trashPath.filename().string();
    const char *cPath = path.remove_filename().c_str();

    char sql[] =  "INSERT INTO trash (OBJECTNAME, FILESIZE, TRASHPATH, OLDPATH, DELETEDAT) "
                        "VALUES (?, ?, ?, ?, datetime('NOW', 'localtime'));";
    dbStatus = sqlite3_prepare(db, sql, -1, &stmt, 0);
    if (dbStatus != SQLITE_OK)
    {
        std::cout << "Database Error: " << errMsg << std::endl;
        exit(0);
    }

    if (sqlite3_bind_text(stmt, 1, objectName.c_str(), -1, SQLITE_STATIC) != SQLITE_OK)
        std::cout << "Database Bind Error: " << sqlite3_errmsg(db) << std::endl;
    if (sqlite3_bind_int(stmt, 2, static_cast<int>(size)) != SQLITE_OK)
        std::cout << "Database Bind Error: " << sqlite3_errmsg(db) << std::endl;
    if (sqlite3_bind_text(stmt, 3, trashPath.c_str(), -1, SQLITE_STATIC) != SQLITE_OK)
        std::cout << "Database Bind Error: " << sqlite3_errmsg(db) << std::endl;
    if (sqlite3_bind_text(stmt, 4, cPath, -1, SQLITE_STATIC))
        std::cout << "Database Bind Error: " << sqlite3_errmsg(db) << std::endl;

    if (sqlite3_step(stmt) != SQLITE_DONE)
        std::cout << "Database Execute Error: " << sqlite3_errmsg(db) << std::endl;
}

bool CCompilerDriver::compile(const fs::path &inputPath, const fs::path &outputPath)
{
    string intermediateName = "__" + outputPath.filename().generic_string() + ".cpp";
    fs::path intermediatePath = outputPath;
    intermediatePath.remove_filename();
    intermediatePath /= intermediateName;

    string code;
    if (!generateCode(inputPath, code))
    {
        return false;
    }

    ofstream out;
    out.open(intermediatePath.generic_string().c_str(), ofstream::out);
    out.write(code.c_str(), code.size());
    out.close();

    stringstream command;
    command << "clang++ " << intermediatePath << " -o " << outputPath;
    cout << "Executing: " << command.str() << std::endl;
    system(command.str().c_str());

    return true;
}

fs::path FileResolver::resolve(const fs::path &path) const {
	/* First, try to resolve in case-sensitive mode */
	for (size_t i=0; i<m_paths.size(); i++) {
		fs::path newPath = m_paths[i] / path;
		if (fs::exists(newPath))
			return newPath;
	}

	#if defined(__LINUX__)
		/* On Linux, also try case-insensitive mode if the above failed */
		fs::path parentPath = path.parent_path();
		std::string filename = boost::to_lower_copy(path.filename().string());

		for (size_t i=0; i<m_paths.size(); i++) {
			fs::path path = m_paths[i] / parentPath;

			if (!fs::is_directory(path))
				continue;

			fs::directory_iterator end, it(path);
			for (; it != end; ++it) {
				if (boost::algorithm::to_lower_copy(it->path().filename().string()) == filename)
					return it->path();
			}
		}
	#endif

	return path;
}

void AudioVisualizerApp::playAudio( const fs::path& file )
{
	FMOD_RESULT err;

	// ignore if this is not a file
	if( file.empty() || !fs::is_regular_file( file ) )
		return;

	// if audio is already playing, stop it first
	stopAudio();

	// stream the audio
	err = mFMODSystem->createStream( file.string().c_str(), FMOD_SOFTWARE, NULL, &mFMODSound );
	err = mFMODSystem->playSound( FMOD_CHANNEL_FREE, mFMODSound, false, &mFMODChannel );

	// we want to be notified of channel events
	err = mFMODChannel->setCallback( channelCallback );

	// keep track of the audio file
	mAudioPath = file;
	mIsAudioPlaying = true;

	// 
	console() << "Now playing:" << mAudioPath.filename() << std::endl;
}

void QuickTimeSampleApp::loadMovieFile( const fs::path &moviePath )
{
	try {
		// load up the movie, set it to loop, and begin playing
		mMovie = qtime::MovieGl::create( moviePath );
		mMovie->setLoop();
		mMovie->play();
		
		// create a texture for showing some info about the movie
		TextLayout infoText;
		infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
		infoText.setColor( Color::white() );
		infoText.addCenteredLine( moviePath.filename().string() );
		infoText.addLine( toString( mMovie->getWidth() ) + " x " + toString( mMovie->getHeight() ) + " pixels" );
		infoText.addLine( toString( mMovie->getDuration() ) + " seconds" );
		infoText.addLine( toString( mMovie->getNumFrames() ) + " frames" );
		infoText.addLine( toString( mMovie->getFramerate() ) + " fps" );
		infoText.setBorder( 4, 2 );
		mInfoTexture = gl::Texture::create( infoText.render( true ) );
	}
	catch( ci::Exception &exc ) {
		console() << "Exception caught trying to load the movie from path: " << moviePath << ", what: " << exc.what() << std::endl;
		mMovie.reset();
		mInfoTexture.reset();
	}

	mFrameTexture.reset();
}

void redEyeApp::loadShader() {
    mError= "";
    try {
        mTimeFrag= fs::last_write_time(mPathFrag);
        mTimeVert= fs::last_write_time(mPathVert);
        mNameFrag= mPathFrag.filename().string();
        mNameVert= mPathVert.filename().string();
        mShader= gl::GlslProg::create(loadFile(mPathVert), loadFile(mPathFrag), NULL);
    }
    catch(gl::GlslProgCompileExc &exc) {
        mError= exc.what();
    }
    catch(...) {
        mError= "Unable to load shader";
    }
}

bool can::put(const fs::path& path)
{
	int i = 0;
	std::ostringstream oss;
	std::string name;
	do
	{
		oss.str("");
		oss << path.filename().string()
			<< " - " << trashinfo::get_current_time()
			<< " - " << i;
		name = oss.str();
		oss << ".trashinfo";
		try
		{
			trashinfo::create(this->info.as<fs::path>() / oss.str(), path);
			i = 0;
		}
		catch(const std::runtime_error& e)
		{
			i++;
		}
	} while (i > 0);

	boost::system::error_code ec;

	fs::rename(fs::absolute(path), this->files.as<fs::path>() / name, ec);

	return !ec;
}

void QTimeline::load( fs::path filepath )
{
    clear();
 
    XmlTree doc;
    
    try
    {
        doc = XmlTree( loadFile( filepath ) );

        
        for( XmlTree::Iter nodeIt = doc.begin("QTimeline/tracks/track"); nodeIt != doc.end(); ++nodeIt )
        {
            string              trackName   = nodeIt->getAttributeValue<string>("name");
            QTimelineTrackRef   trackRef    = QTimelineTrackRef( new QTimelineTrack( trackName ) );
            mTracks.push_back( trackRef );
            trackRef->loadXmlNode( *nodeIt );
        }
        
        mCueManager->loadXmlNode( doc.getChild( "qTimeline/cueList" ) );
    }
    catch ( ... )
    {
        console() << "Error > QTimeline::load(): " << filepath.filename().generic_string() << endl;
        return;
    }
    
    updateCurrentTime();
}

void DXTencoderApp::loadMovieFile( const fs::path &moviePath )
{
    try {
        mMovie = qtime::MovieSurface::create( moviePath );
        
        console() << "Dimensions:" << mMovie->getWidth() << " x " << mMovie->getHeight() << std::endl;
        console() << "Duration:  " << mMovie->getDuration() << " seconds" << std::endl;
        console() << "Frames:    " << mMovie->getNumFrames() << std::endl;
        console() << "Framerate: " << mMovie->getFramerate() << std::endl;
        console() << "Has audio: " << mMovie->hasAudio() << " Has visuals: " << mMovie->hasVisuals() << std::endl;

        mMovie->setLoop( false );
        mMovie->seekToStart();
        //mMovie->play();
        isStarted = true;
        currentFrame = 0;

        
        std::string basePath = moviePath.parent_path().string();
        string newFilename =   moviePath.filename().string();
        strReplace(newFilename, moviePath.extension().string(), ".dxt5");
                                                  
        mDxtCreator.open(basePath + "/" + newFilename);

    }
    catch( ci::Exception &exc ) {
        console() << "Exception caught trying to load the movie from path: " << moviePath << ", what: " << exc.what() << std::endl;
    }
    
    
    
}

void AssetReloader::reloadAsset( fs::path assetPath )
{
    
    //    console() << "reload :: " << mKeyList[ assetPath.c_str() ] << endl;
    
    string key = "";
    key = mKeyList[ assetPath.c_str() ];
    
    if( key != "" ){
        console() << "AssetReloader :: reloading asset :: " << assetPath.filename() << endl;
        load( assetPath.filename(), key );
        // fire signal
        sAssetReloaded();
    }else{
        console() << "AssetReloader :: can't reload " << assetPath.filename() << endl;
    }
}

/*
 * Deal the stacks into separated files and append them.
 */
void dealStack(const fs::path &outdir, const std::string &prefix,
               const fs::path &imgPath,
               const uint16_t nLayer) {
	TIFF *in, *out;
    static uint16_t iLayer = 0;

    // Suppress the warnings.
	TIFFErrorHandler oldhandler = TIFFSetWarningHandler(NULL);

	// Open the file.
	in = TIFFOpen(imgPath.string().c_str(), "r");
	if (in == NULL) {
		std::cerr << "Unable to read " << imgPath.filename() << std::endl;
		return;
	}

    // Identify the read mode.
	static char mode[3] = { 'x', 'b', 0 };
    // Overwrite on the first run, and append for rest of the page.
    mode[0] = (mode[0] == 'x') ? 'w' : 'a';
    mode[1] = (TIFFIsBigEndian(in)) ? 'b' : 'l';

	// Iterate through the directories.
	int iFile = 0;
	do {
        std::string s = genPath(outdir, prefix, iFile);
		out = TIFFOpen(s.c_str(), mode);
        try {
    		if (out == NULL) {
                throw -1;
    		} else if (!cpTiff(in, out, iLayer, nLayer)) {
                throw -2;
    		}
        } catch (int e) {
            if (e == -1) {
                std::cerr << "Unable to create output file" << std::endl;
            } else if (e == -2) {
                std::cerr << "Unable to copy the layer" << std::endl;
            } else {
                std::cerr << "Unknown error" << std::endl;
            }
            TIFFClose(in);
            TIFFClose(out);
            return;
        }
		TIFFClose(out);
		iFile++;
	} while (TIFFReadDirectory(in));

    // Increment the layer variable for next write.
    iLayer++;

	TIFFClose(in);

    // Restore the warning.
	TIFFSetWarningHandler(oldhandler);
}

bool bcp_implementation::is_html_file(const fs::path& p)
{
   static const boost::regex e(
      ".*\\."
      "(?:"
         "html?|css"
      ")"
      );
   return boost::regex_match(p.filename().generic_string(), e);
}