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

fs::path uniquify(const fs::path &dest)
{
    std::string ext = dest.extension();
    std::string fname = dest.stem();
    fs::path parent = dest.parent_path();

    unsigned number = 1;
    std::string newfname;
    fs::path newdest;

    boost::smatch match;
    if(boost::regex_search(fname, match, uregex)) {
        // Matches are indexes into fname, so don't change it while reading values
        newfname = match[1];
        number = boost::lexical_cast<short>(match[2]);
        fname = newfname;
    }

    do { 
        newfname = fname + "(" + boost::lexical_cast<std::string>(++number) + ")" + ext;
        newdest = parent / newfname;
    } while(fs::exists(newdest));

    return newdest;
}

void ScintillaEditor::enumerateColorSchemesInPath(ScintillaEditor::colorscheme_set_t &result_set, const fs::path path)
{
	const fs::path color_schemes = path / "color-schemes" / "editor";

	fs::directory_iterator end_iter;

	if (fs::exists(color_schemes) && fs::is_directory(color_schemes)) {
		for (fs::directory_iterator dir_iter(color_schemes); dir_iter != end_iter; ++dir_iter) {
			if (!fs::is_regular_file(dir_iter->status())) {
				continue;
			}

			const fs::path path = (*dir_iter).path();
			if (!(path.extension() == ".json")) {
				continue;
			}

			EditorColorScheme *colorScheme = new EditorColorScheme(path);
			if (colorScheme->valid()) {
				result_set.insert(colorscheme_set_t::value_type(colorScheme->index(), shared_ptr<EditorColorScheme>(colorScheme)));
			} else {
				delete colorScheme;
			}
		}
	}
}

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;
    }
    
    
    
}

	bool FileFinder::fileExtMatch(const fs::path test)
	{
		if (m_ext == "*")
			return(true);
		else if (m_ext == test.extension())
			return(true);
		else
			return(false);
	}

// Functor operator, gets invoked on directory traversal
void ModuleLoader::processModuleFile(const fs::path& file)
{
	// Check for the correct extension of the visited file
	if (string::to_lower_copy(file.extension().string()) != MODULE_FILE_EXTENSION) return;

	std::string fullName = file.string();
	rConsole() << "ModuleLoader: Loading module '" << fullName << "'" << std::endl;

	// Create the encapsulator class
	DynamicLibraryPtr library = std::make_shared<DynamicLibrary>(fullName);

	// greebo: Try to find our entry point and invoke it and add the library to the list
	// on success. If the load fails, the shared pointer won't be added and
	// self-destructs at the end of this scope.
	if (library->failed())
	{
		rError() << "WARNING: Failed to load module " << library->getName() << ":" << std::endl;

#ifdef __linux__
		rConsoleError() << dlerror() << std::endl;
#endif
		return;
	}

	// Library was successfully loaded, lookup the symbol
	DynamicLibrary::FunctionPointer funcPtr(
		library->findSymbol(SYMBOL_REGISTER_MODULE)
	);

	if (funcPtr == nullptr)
	{
		// Symbol lookup error
		rError() << "WARNING: Could not find symbol " << SYMBOL_REGISTER_MODULE
			<< " in module " << library->getName() << ":" << std::endl;
		return;
	}

	// Brute-force conversion of the pointer to the desired type
	RegisterModulesFunc regFunc = reinterpret_cast<RegisterModulesFunc>(funcPtr);

	try
	{
		// Call the symbol and pass a reference to the ModuleRegistry
		// This method might throw a ModuleCompatibilityException in its
		// module::performDefaultInitialisation() routine.
		regFunc(ModuleRegistry::Instance());

		// Add the library to the static list (for later reference)
		_dynamicLibraryList.push_back(library);
	}
	catch (module::ModuleCompatibilityException&)
	{
		// Report this error and don't add the module to the _dynamicLibraryList
		rError() << "Compatibility mismatch loading library " << library->getName() << std::endl;
	}
}

std::string MimetypeFromExtension( const fs::path &filepath )
{
    std::string extension = Util::BoostPathToUtf8Path( filepath.extension() );
    boost::erase_first( extension, "." );

    if ( extension == "xhtml" ||
         extension == "html"  ||
         extension == "htm" )
    {
        // Only the xhtml mimetype is valid
        // within epub, "text/html" is not
        return XHTML_MIME;
    }

    if ( extension == "png" )
    
        return PNG_MIME;    

    if ( extension == "gif" )
    
        return GIF_MIME;    

    if ( extension == "jpg" ||
         extension == "jpeg" )
    {
        return JPEG_MIME;
    }

    if ( extension == "css" )
    
        return CSS_MIME;    

    if ( extension == "ncx" )
    
        return NCX_MIME;
    
    if ( extension == "svg" )
    
        return SVG_MIME;    

    if ( extension == "otf" )
    
        return OTF_MIME;

    if ( extension == "ttf" )
    
        return TTF_MIME; 
        
    // We don't check for "xml" because
    // that's commonly used for several things.

    return UNKNOWN_MIME;
}

Save::Save(fs::path const& file, bool binary)
: file_name(file)
, tmp_name(unique_path(file.parent_path()/(file.stem().string() + "_tmp_%%%%" + file.extension().string())))
{
	LOG_D("agi/io/save/file") << file;

	fp = agi::make_unique<boost::filesystem::ofstream>(tmp_name, binary ? std::ios::binary : std::ios::out);
	if (!fp->good()) {
		acs::CheckDirWrite(file.parent_path());
		acs::CheckFileWrite(file);
		throw fs::WriteDenied(tmp_name);
	}
}

void SimpleViewerApp::load( fs::path path )
{
	try {
		if( path.extension() != ".svgz" ) 
			mDoc = svg::Doc::create( path );
		else // compressed
			mDoc = svg::Doc::createFromSvgz( loadFile( path ) );
		
		mTex = renderCairoToTexture( mDoc );
	}
	catch( ... ) {
	} // ignore errors
}

void SpriteSheetGeneratorApp::addFile(const fs::path &file)
{
  set<string> extensions = { ".png", ".jpg", ".gif", ".tiff", ".tif", ".tga" };
  if( fs::exists( file ) )
  {
    cout << "Checking file: " << file << ", extension: " << file.extension().string() << endl;
    if( fs::is_regular_file( file ) && extensions.count(file.extension().string()) )
    {
      cout << "Adding file: " << file << endl;
      Surface img = loadImage( file );
      string id = file.stem().string();
      mWidestImage = max( img.getWidth(), mWidestImage );
      auto sprite = mImagePacker.addImage( id, img );
      sprite->setRegistrationPoint( Vec2i( sprite->getWidth() / 2, sprite->getHeight() ) );
    }
    else if( fs::is_directory( file ) )
    {
      for( auto iter = fs::directory_iterator( file ); iter != fs::directory_iterator(); ++iter )
      {
        addFile( *iter );
      }
    }
  }
}

/*******************************************************************
 * Function Name: GiveSegImgPath
 * Return Type 	: const fs::path
 * Created On	: Aug 21, 2013
 * Created By 	: hrushi
 * Comments		: For the given image path. It creates a segmentation folder and returns the path where the image could be stored
 * Arguments	: const fs::path& ImgPath
 *******************************************************************/
const fs::path Detect::GiveSegImgPath( const fs::path& iPath, const string Suffix)
{
	fs::path SegImgPath;


	fs::path SegFldr = iPath.parent_path().string() + "/Seg";
	fs::create_directory(SegFldr);

	string OutputPath;
	OutputPath = SegFldr.parent_path().string() + "/Seg/";
	OutputPath +=  iPath.stem().string() + Suffix;
	OutputPath +=  iPath.extension().string();

	SegImgPath = OutputPath;

	return SegImgPath;
}

void AnimatedRevealApp::load( const fs::path &path )
{
    mMinRenderElement = 0;
    try {
        if( path.extension() == ".svgz" ) // compressed
            mDoc = svg::Doc::createFromSvgz( loadFile( path ) );
        else
            mDoc = svg::Doc::create( loadFile( path ) );

        mDone = false;
#if defined( RECORD_MOVIE )
        mMovie = qtime::MovieWriter( fs::path( getHomeDirectory() + "AnimatedReveal.mov" ), mDoc->getWidth(), mDoc->getHeight() );
#endif
    }
    catch( ci::Exception &exc ) {
        console() << "failed to load doc, what: " << exc.what() << endl;
    }
}

unsigned OpenALAudio::load( const fs::path &filename )
{
    ALuint bufferId = 0;
    alGenBuffers( 1, &bufferId );

    FILE *file = fopen( filename.string().c_str(), "rb" );
    if ( !file )
		throw OpenALAudioExc( "Error opening " + filename.string() );

	string extension = filename.extension().string();

	if ( extension == ".ogg" )
	{
		loadOgg( filename, file, bufferId );
	}
	else
	{
		throw OpenALAudioExc( "Unknown file format " + extension );
	}

	return bufferId;
}

bool ScanThread::isSupportedExtension(const fs::path& fileName)
{
	return extensions_.find(fileName.extension().string()) != extensions_.end();
}