org.eclipse.efm.symbex/src/util/avm_vfs.cpp - efm/org.eclipse.efm-symbex - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016 CEA LIST.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Created on: 26 mars 2015
  *
  * Contributors:
  *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
  *   - Initial API and implementation
  ******************************************************************************/

 #include "avm_vfs.h"

 #include <collection/Typedef.h>

 #include <fstream>

 #include <boost/filesystem.hpp>


 namespace sep
 {

 std::string VFS::ExecutablePath;

 std::string VFS::WorkflowPath;


 std::string VFS::LaunchPath;


 std::string VFS::WorkspaceRootPath;

 std::string VFS::WorkspaceSourcePath;

 std::string VFS::WorkspaceOutputPath;

 std::string VFS::WorkspaceLogPath;

 std::string VFS::WorkspaceDebugPath;

 std::string VFS::WorkspaceTddPath;


 std::string VFS::ProjectPath;

 std::string VFS::ProjectSourcePath;

 std::string VFS::ProjectOutputPath;

 std::string VFS::ProjectLogPath;

 std::string VFS::ProjectDebugPath;

 std::string VFS::ProjectTddPath;


 /**
  * FORMAT NATIVE FILE / DIRECTORY PATH
  */

 static bool is_complete(const boost::filesystem::path & aPath)
 {
 //	return( aPath.is_absolute() );

 	if( aPath.is_complete() )
 	{
 		return( true );
 	}
 	else
 	{
 #ifdef __AVM_BOOST_WINDOWS__
 		std::string root = aPath.root_path().string();
 		return( (root.size() >= 2) &&
 				((root[root.size()-1] == ':')
 				|| (root.find(':') != std::string::npos)   // "c:"
 				|| ((root[0] == '/') && (root[1] == '/'))  // "//share"
 				|| aPath.is_complete()
 				)
 		);
 #else
 		return( aPath.is_complete() );
 #endif
 	}
 //	else if( VFS::IS_WINDOWS_PLATFORM && (! aPath.empty()) )
 //	{
 //		std::string root = aPath.root_path().string();
 //		return( (root.size() == 2) && (root[1] == ':') );
 //	}

 	return( false );
 }


 std::string VFS::native_path(const std::string & path)
 {
 	boost::filesystem::path aPath( path );

 //	if( not is_complete(aPath) )
 //	{
 //		aPath = boost::filesystem::current_path().string() +
 //				"/" + aPath.string();
 //	}
 	aPath.normalize();

 	return( aPath.string() );
 }

 std::string VFS::native_path(
 		const std::string & path, const std::string & main_dir)
 {
 	boost::filesystem::path aPath( path );

 	if( not is_complete(aPath) )
 //	if( aPath.is_relative() )
 	{
 		aPath = main_dir + "/" + aPath.string();
 		aPath.normalize();
 	}

 	return( aPath.string() );
 }

 // CYGWIN
 std::string VFS::posix_path(const std::string & path)
 {
 //	if( VFS::IS_CYGWYN_PLATFORM )
 #ifdef __AVM_BOOST_CYGWIN__
 	if( (path.size() > 2) && (path[1] == ':') )
 	{
 		path[0] = tolower(path[0]);
 		path[1] = '/';
 		if( (path[2] == '/') || (path[2] == '\\') )
 		{
 			path = "/cygdrive/" + path.substr(0, 2) + path.substr(3) ;
 		}
 		else
 		{
 			path = "/cygdrive/" + path;
 		}
 	}
 #endif

 	return( path );
 }


 /**
  * CHECKER FOR READING / WRITING  FILE / DIRECTORY PATH
  */
 bool VFS::checkReadingFile(const std::string & path)
 {
 	try
 	{
 		boost::filesystem::path aPath( path );

 		return( boost::filesystem::exists(aPath) /*&&
 				boost::filesystem::is_regular_file(aPath)*/ );
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_CERR << std::endl
 				<< EMPHASIS("std::exception:>", e.what(), '*', 80);
 	}

 	return( false );
 }

 bool VFS::checkWritingFile(const std::string & path)
 {
 	std::ofstream checkFileStream(path.c_str());

 	return( checkFileStream.good() );
 }

 bool VFS::checkWritingFileFolder(const std::string & path)
 {
 	std::string::size_type pos = path.find_last_of( VFS::PathSeparator );

 	if( pos != std::string::npos )
 	{
 		if( not VFS::checkWritingFolder( path.substr(0, pos) ) )
 		{
 			return( false );
 		}
 	}

 	return( VFS::checkWritingFile( path ) );
 }


 bool VFS::checkReadingFolder(const std::string & dir_path)
 {
 	try
 	{
 		boost::filesystem::path aPath( dir_path );

 		return( boost::filesystem::exists(aPath) &&
 				boost::filesystem::is_directory(aPath) );
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_CERR << std::endl
 				<< EMPHASIS("std::exception:>", e.what(), '*', 80);
 	}

 	return( false );
 }

 bool VFS::checkWritingFolder(const std::string & dir_path)
 {
 	try
 	{
 		boost::filesystem::path aPath( dir_path );

 		boost::filesystem::create_directories( aPath );

 		return( true );
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_CERR << std::endl
 				<< EMPHASIS("std::exception:>", e.what(), '*', 80);

 		return( false );
 	}

 	return( false );
 }


 /**
  * List all file
  */
 bool VFS::listAllFiles(const std::string & dir_path,
 		std::vector< std::string > & listOfFiles, bool recursive)
 {
 	if( VFS::checkReadingFolder(dir_path) )
 	{
 		boost::filesystem::path aPath( dir_path );

 		boost::filesystem::directory_iterator end_itr;
 		boost::filesystem::directory_iterator itr(aPath);

 		for( ; itr != end_itr ; ++itr )
 		{
 			// If it's not a directory, list it.
 			// If you want to list directories too, just remove this check.
 			if( boost::filesystem::is_regular_file( itr->status() ) )
 			{
 				if( VFS::checkReadingFile( itr->path().string() ) )
 				{
 					listOfFiles.push_back( itr->path().string() );
 				}
 			}
 			else if( recursive &&
 					boost::filesystem::is_directory( itr->status() ) )
 			{
 				if( VFS::listAllFiles(itr->path().string(), listOfFiles, true) )
 				{
 					//!! continue
 				}
 			}
 		}

 		return( true );
 	}

 	return( false );
 }


 /**
  * copy / move
  */
 bool VFS::copyTo(
 		const std::string & srcLocation,
 		const std::string & destLocation)
 {
 	try
 	{
 		boost::filesystem::copy_file(srcLocation, destLocation,
 				boost::filesystem::copy_option::overwrite_if_exists);

 		return( true );
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 				"VFS::copyToFolder< std::exception >", e.what(), '*', 80);
 	}
 	catch( ... )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 			"VFS::copyToFolder< unknown::exception > !!!", '*', 80 );
 	}

 	return( false );
 }

 bool VFS::copyToFolder(
 		const std::string & srcLocation,
 		const std::string & destLocation)
 {
 	try
 	{
 		boost::filesystem::path srcPath( srcLocation );
 		boost::filesystem::path destPath( destLocation );

 		destPath /= srcPath.filename();

 		boost::filesystem::copy_file(srcPath, destPath,
 				boost::filesystem::copy_option::overwrite_if_exists);

 		return( true );
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 				"VFS::copyToFolder< std::exception >", e.what(), '*', 80);
 	}
 	catch( ... )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 			"VFS::copyToFolder< unknown::exception > !!!", '*', 80);
 	}

 	return( false );
 }


 bool VFS::moveTo(
 		const std::string & srcLocation,
 		const std::string & destLocation)
 {
 	try
 	{
 		if( VFS::copyTo(srcLocation, destLocation) )
 		{
 			return( boost::filesystem::remove( srcLocation ) );
 		}
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 				"VFS::moveToFolder< std::exception >", e.what(), '*', 80);
 	}
 	catch( ... )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 			"VFS::moveToFolder< unknown::exception > !!!", '*', 80);
 	}

 	return( false );
 }

 bool VFS::moveToFolder(
 		const std::string & srcLocation, const std::string & destLocation)
 {
 	try
 	{
 		if( VFS::copyToFolder(srcLocation, destLocation) )
 		{
 			return( boost::filesystem::remove( srcLocation ) );
 		}
 	}
 	catch( const std::exception & e )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 				"VFS::moveToFolder< std::exception >", e.what(), '*', 80);
 	}
 	catch( ... )
 	{
 		AVM_OS_WARN << std::endl << EMPHASIS(
 			"VFS::moveToFolder< unknown::exception > !!!", '*', 80);
 	}

 	return( false );
 }


 /**
  * UTILS
  */
 const char VFS::PathSeparator =
 		boost::filesystem::path::preferred_separator;


 bool VFS::isPathSeparator(char c)
 {
 	return( (c == boost::filesystem::path::preferred_separator) ||
 			(c == ('/')) || (c == ('\\')) );
 }


 std::string VFS::parent(const std::string & aLocation)
 {
 	boost::filesystem::path aPath( aLocation );

 	return( aPath.parent_path().string() );
 }

 std::string VFS::filename(const std::string & aLocation)
 {
 	boost::filesystem::path aPath( aLocation );

 	return( aPath.filename().string() );
 }

 std::string VFS::stem(const std::string & aLocation)
 {
 	boost::filesystem::path aPath( aLocation );

 	return( aPath.stem().string() );
 }

 std::string VFS::extension(const std::string & aLocation)
 {
 	boost::filesystem::path aPath( aLocation );

 	return( aPath.extension().string() );
 }

 std::string VFS::replace_extension(
 		const std::string & aLocation, const std::string & anExtension)
 {
 	boost::filesystem::path aPath( aLocation );

 	boost::filesystem::path newPath = aPath.replace_extension(anExtension);

 	return( newPath.string() );
 }


 std::string VFS::prefixFilename(const std::string & aLocation,
 		const std::string & aPrefix, const std::string & newExtension)
 {
 	boost::filesystem::path aPath( aLocation );

 	boost::filesystem::path newPath = aPath.parent_path();

 	newPath /= aPrefix + aPath.filename().string();

 	if( newExtension.size() > 1 )
 	{
 		newPath = newPath.replace_extension(newExtension);
 	}

 	return( newPath.string() );
 }

 std::string VFS::suffixFilename(const std::string & aLocation,
 		const std::string & aPrefix, const std::string & newExtension)
 {
 	boost::filesystem::path aPath( aLocation );

 	boost::filesystem::path newPath = aPath.parent_path();
 	newPath /= aPath.stem().string() + aPrefix +
 			( (newExtension.size() > 1) ?
 					newExtension : aPath.extension().string() );

 	return( newPath.string() );
 }


 std::string VFS::relativePath(const std::string & refPath,
 		const std::string & aPath, const std::string & newPrefix)
 {
 	if( refPath.size() < aPath.size() )
 	{
 		std::string::size_type pos = 0;

 		for( ; pos < refPath.size() ; ++pos )
 		{
 			if( (refPath[pos] != aPath[pos]) &&
 				(not isPathSeparator(refPath[pos])) &&
 				(not isPathSeparator(aPath[pos])) )
 			{
 				break;
 			}
 		}

 		if( pos > 0 )
 		{
 			if( newPrefix.empty() )
 			{
 				while( isPathSeparator(aPath[pos]) )
 				{
 					++pos;
 				}

 				return( aPath.substr(pos) );
 			}

 			return( newPrefix + aPath.substr(pos) );
 		}
 	}
 	else if( refPath.size() == aPath.size() )
 	{
 		return( newPrefix + "./" );
 	}

 	return( aPath );
 }


 std::string VFS::wrapPath(const std::string & aPath,
 		std::size_t wrapSize, const std::string & newPrefix)
 {
 	if( aPath.size() > wrapSize )
 	{
 		std::string::size_type posSeparator = 0;

 		for( std::string::size_type pos = 0 ; pos < aPath.size() ; ++pos )
 		{
 			if( isPathSeparator(aPath[pos]) )
 			{
 				posSeparator = pos;
 				if( wrapSize >= (aPath.size() - pos) )
 				{
 					break;
 				}
 			}
 		}

 		if( posSeparator > 0 )
 		{
 			return( newPrefix + aPath.substr(posSeparator) );
 		}

 		return( aPath );
 	}

 	return( aPath );
 }


 } /* namespace sep */
	/*******************************************************************************
	* Copyright (c) 2016 CEA LIST.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Created on: 26 mars 2015
	*
	* Contributors:
	* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
	* - Initial API and implementation
	******************************************************************************/

	#include "avm_vfs.h"

	#include <collection/Typedef.h>

	#include <fstream>

	#include <boost/filesystem.hpp>


	namespace sep
	{

	std::string VFS::ExecutablePath;

	std::string VFS::WorkflowPath;


	std::string VFS::LaunchPath;


	std::string VFS::WorkspaceRootPath;

	std::string VFS::WorkspaceSourcePath;

	std::string VFS::WorkspaceOutputPath;

	std::string VFS::WorkspaceLogPath;

	std::string VFS::WorkspaceDebugPath;

	std::string VFS::WorkspaceTddPath;


	std::string VFS::ProjectPath;

	std::string VFS::ProjectSourcePath;

	std::string VFS::ProjectOutputPath;

	std::string VFS::ProjectLogPath;

	std::string VFS::ProjectDebugPath;

	std::string VFS::ProjectTddPath;




	/**
	* FORMAT NATIVE FILE / DIRECTORY PATH
	*/

	static bool is_complete(const boost::filesystem::path & aPath)
	{
	// return( aPath.is_absolute() );

	if( aPath.is_complete() )
	{
	return( true );
	}
	else
	{
	#ifdef __AVM_BOOST_WINDOWS__
	std::string root = aPath.root_path().string();
	return( (root.size() >= 2) &&
	((root[root.size()-1] == ':')
	\|\| (root.find(':') != std::string::npos) // "c:"
	\|\| ((root[0] == '/') && (root[1] == '/')) // "//share"
	\|\| aPath.is_complete()
	)
	);
	#else
	return( aPath.is_complete() );
	#endif
	}
	// else if( VFS::IS_WINDOWS_PLATFORM && (! aPath.empty()) )
	// {
	// std::string root = aPath.root_path().string();
	// return( (root.size() == 2) && (root[1] == ':') );
	// }

	return( false );
	}


	std::string VFS::native_path(const std::string & path)
	{
	boost::filesystem::path aPath( path );

	// if( not is_complete(aPath) )
	// {
	// aPath = boost::filesystem::current_path().string() +
	// "/" + aPath.string();
	// }
	aPath.normalize();

	return( aPath.string() );
	}

	std::string VFS::native_path(
	const std::string & path, const std::string & main_dir)
	{
	boost::filesystem::path aPath( path );

	if( not is_complete(aPath) )
	// if( aPath.is_relative() )
	{
	aPath = main_dir + "/" + aPath.string();
	aPath.normalize();
	}

	return( aPath.string() );
	}

	// CYGWIN
	std::string VFS::posix_path(const std::string & path)
	{
	// if( VFS::IS_CYGWYN_PLATFORM )
	#ifdef __AVM_BOOST_CYGWIN__
	if( (path.size() > 2) && (path[1] == ':') )
	{
	path[0] = tolower(path[0]);
	path[1] = '/';
	if( (path[2] == '/') \|\| (path[2] == '\\') )
	{
	path = "/cygdrive/" + path.substr(0, 2) + path.substr(3) ;
	}
	else
	{
	path = "/cygdrive/" + path;
	}
	}
	#endif

	return( path );
	}


	/**
	* CHECKER FOR READING / WRITING FILE / DIRECTORY PATH
	*/
	bool VFS::checkReadingFile(const std::string & path)
	{
	try
	{
	boost::filesystem::path aPath( path );

	return( boost::filesystem::exists(aPath) /*&&
	boost::filesystem::is_regular_file(aPath)*/ );
	}
	catch( const std::exception & e )
	{
	AVM_OS_CERR << std::endl
	<< EMPHASIS("std::exception:>", e.what(), '*', 80);
	}

	return( false );
	}

	bool VFS::checkWritingFile(const std::string & path)
	{
	std::ofstream checkFileStream(path.c_str());

	return( checkFileStream.good() );
	}

	bool VFS::checkWritingFileFolder(const std::string & path)
	{
	std::string::size_type pos = path.find_last_of( VFS::PathSeparator );

	if( pos != std::string::npos )
	{
	if( not VFS::checkWritingFolder( path.substr(0, pos) ) )
	{
	return( false );
	}
	}

	return( VFS::checkWritingFile( path ) );
	}


	bool VFS::checkReadingFolder(const std::string & dir_path)
	{
	try
	{
	boost::filesystem::path aPath( dir_path );

	return( boost::filesystem::exists(aPath) &&
	boost::filesystem::is_directory(aPath) );
	}
	catch( const std::exception & e )
	{
	AVM_OS_CERR << std::endl
	<< EMPHASIS("std::exception:>", e.what(), '*', 80);
	}

	return( false );
	}

	bool VFS::checkWritingFolder(const std::string & dir_path)
	{
	try
	{
	boost::filesystem::path aPath( dir_path );

	boost::filesystem::create_directories( aPath );

	return( true );
	}
	catch( const std::exception & e )
	{
	AVM_OS_CERR << std::endl
	<< EMPHASIS("std::exception:>", e.what(), '*', 80);

	return( false );
	}

	return( false );
	}


	/**
	* List all file
	*/
	bool VFS::listAllFiles(const std::string & dir_path,
	std::vector< std::string > & listOfFiles, bool recursive)
	{
	if( VFS::checkReadingFolder(dir_path) )
	{
	boost::filesystem::path aPath( dir_path );

	boost::filesystem::directory_iterator end_itr;
	boost::filesystem::directory_iterator itr(aPath);

	for( ; itr != end_itr ; ++itr )
	{
	// If it's not a directory, list it.
	// If you want to list directories too, just remove this check.
	if( boost::filesystem::is_regular_file( itr->status() ) )
	{
	if( VFS::checkReadingFile( itr->path().string() ) )
	{
	listOfFiles.push_back( itr->path().string() );
	}
	}
	else if( recursive &&
	boost::filesystem::is_directory( itr->status() ) )
	{
	if( VFS::listAllFiles(itr->path().string(), listOfFiles, true) )
	{
	//!! continue
	}
	}
	}

	return( true );
	}

	return( false );
	}


	/**
	* copy / move
	*/
	bool VFS::copyTo(
	const std::string & srcLocation,
	const std::string & destLocation)
	{
	try
	{
	boost::filesystem::copy_file(srcLocation, destLocation,
	boost::filesystem::copy_option::overwrite_if_exists);

	return( true );
	}
	catch( const std::exception & e )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::copyToFolder< std::exception >", e.what(), '*', 80);
	}
	catch( ... )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::copyToFolder< unknown::exception > !!!", '*', 80 );
	}

	return( false );
	}

	bool VFS::copyToFolder(
	const std::string & srcLocation,
	const std::string & destLocation)
	{
	try
	{
	boost::filesystem::path srcPath( srcLocation );
	boost::filesystem::path destPath( destLocation );

	destPath /= srcPath.filename();

	boost::filesystem::copy_file(srcPath, destPath,
	boost::filesystem::copy_option::overwrite_if_exists);

	return( true );
	}
	catch( const std::exception & e )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::copyToFolder< std::exception >", e.what(), '*', 80);
	}
	catch( ... )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::copyToFolder< unknown::exception > !!!", '*', 80);
	}

	return( false );
	}


	bool VFS::moveTo(
	const std::string & srcLocation,
	const std::string & destLocation)
	{
	try
	{
	if( VFS::copyTo(srcLocation, destLocation) )
	{
	return( boost::filesystem::remove( srcLocation ) );
	}
	}
	catch( const std::exception & e )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::moveToFolder< std::exception >", e.what(), '*', 80);
	}
	catch( ... )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::moveToFolder< unknown::exception > !!!", '*', 80);
	}

	return( false );
	}

	bool VFS::moveToFolder(
	const std::string & srcLocation, const std::string & destLocation)
	{
	try
	{
	if( VFS::copyToFolder(srcLocation, destLocation) )
	{
	return( boost::filesystem::remove( srcLocation ) );
	}
	}
	catch( const std::exception & e )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::moveToFolder< std::exception >", e.what(), '*', 80);
	}
	catch( ... )
	{
	AVM_OS_WARN << std::endl << EMPHASIS(
	"VFS::moveToFolder< unknown::exception > !!!", '*', 80);
	}

	return( false );
	}


	/**
	* UTILS
	*/
	const char VFS::PathSeparator =
	boost::filesystem::path::preferred_separator;


	bool VFS::isPathSeparator(char c)
	{
	return( (c == boost::filesystem::path::preferred_separator) \|\|
	(c == ('/')) \|\| (c == ('\\')) );
	}


	std::string VFS::parent(const std::string & aLocation)
	{
	boost::filesystem::path aPath( aLocation );

	return( aPath.parent_path().string() );
	}

	std::string VFS::filename(const std::string & aLocation)
	{
	boost::filesystem::path aPath( aLocation );

	return( aPath.filename().string() );
	}

	std::string VFS::stem(const std::string & aLocation)
	{
	boost::filesystem::path aPath( aLocation );

	return( aPath.stem().string() );
	}

	std::string VFS::extension(const std::string & aLocation)
	{
	boost::filesystem::path aPath( aLocation );

	return( aPath.extension().string() );
	}

	std::string VFS::replace_extension(
	const std::string & aLocation, const std::string & anExtension)
	{
	boost::filesystem::path aPath( aLocation );

	boost::filesystem::path newPath = aPath.replace_extension(anExtension);

	return( newPath.string() );
	}


	std::string VFS::prefixFilename(const std::string & aLocation,
	const std::string & aPrefix, const std::string & newExtension)
	{
	boost::filesystem::path aPath( aLocation );

	boost::filesystem::path newPath = aPath.parent_path();

	newPath /= aPrefix + aPath.filename().string();

	if( newExtension.size() > 1 )
	{
	newPath = newPath.replace_extension(newExtension);
	}

	return( newPath.string() );
	}

	std::string VFS::suffixFilename(const std::string & aLocation,
	const std::string & aPrefix, const std::string & newExtension)
	{
	boost::filesystem::path aPath( aLocation );

	boost::filesystem::path newPath = aPath.parent_path();
	newPath /= aPath.stem().string() + aPrefix +
	( (newExtension.size() > 1) ?
	newExtension : aPath.extension().string() );

	return( newPath.string() );
	}


	std::string VFS::relativePath(const std::string & refPath,
	const std::string & aPath, const std::string & newPrefix)
	{
	if( refPath.size() < aPath.size() )
	{
	std::string::size_type pos = 0;

	for( ; pos < refPath.size() ; ++pos )
	{
	if( (refPath[pos] != aPath[pos]) &&
	(not isPathSeparator(refPath[pos])) &&
	(not isPathSeparator(aPath[pos])) )
	{
	break;
	}
	}

	if( pos > 0 )
	{
	if( newPrefix.empty() )
	{
	while( isPathSeparator(aPath[pos]) )
	{
	++pos;
	}

	return( aPath.substr(pos) );
	}

	return( newPrefix + aPath.substr(pos) );
	}
	}
	else if( refPath.size() == aPath.size() )
	{
	return( newPrefix + "./" );
	}

	return( aPath );
	}



	std::string VFS::wrapPath(const std::string & aPath,
	std::size_t wrapSize, const std::string & newPrefix)
	{
	if( aPath.size() > wrapSize )
	{
	std::string::size_type posSeparator = 0;

	for( std::string::size_type pos = 0 ; pos < aPath.size() ; ++pos )
	{
	if( isPathSeparator(aPath[pos]) )
	{
	posSeparator = pos;
	if( wrapSize >= (aPath.size() - pos) )
	{
	break;
	}
	}
	}

	if( posSeparator > 0 )
	{
	return( newPrefix + aPath.substr(posSeparator) );
	}

	return( aPath );
	}

	return( aPath );
	}


	} /* namespace sep */