Rose::FileSystem Namespace Reference

Description

Functions for operating on files in a filesystem.

Classes
class	baseNameMatches
	Predicate returning true for matching names. More...

Typedefs
typedef boost::filesystem::path	Path
	Name of entities in a filesystem.
typedef boost::filesystem::directory_iterator	DirectoryIterator
	Iterate over directory contents non-recursively.
typedef boost::filesystem::recursive_directory_iterator	RecursiveDirectoryIterator
	Iterate recursively into subdirectories.

Functions
ROSE_UTIL_API bool	isExisting (const Path &path)
	Predicate returning true if path exists.
ROSE_UTIL_API bool	isFile (const Path &path)
	Predicate returning true for existing regular files.
ROSE_UTIL_API bool	isDirectory (const Path &path)
	Predicate returning true for existing directories.
ROSE_UTIL_API bool	isSymbolicLink (const Path &path)
	Predicate returning true for existing symbolic links.
ROSE_UTIL_API bool	isNotSymbolicLink (const Path &path)
	Predicate returning inverse of isSymbolicLink.
ROSE_UTIL_API Path	createTemporaryDirectory ()
	Create a temporary directory. More...
ROSE_UTIL_API Path	makeNormal (const Path &)
	Normalize a path name. More...
ROSE_UTIL_API Path	makeRelative (const Path &path, const Path &root=boost::filesystem::current_path())
	Make path relative. More...
ROSE_UTIL_API Path	makeAbsolute (const Path &path, const Path &root=boost::filesystem::current_path())
	Make path absolute. More...
ROSE_UTIL_API void	copyFile (const Path &sourceFileName, const Path &destinationFileName)
	Copy a file. More...
ROSE_UTIL_API void	copyFiles (const std::vector< Path > &files, const Path &root, const Path &destinationDirectory)
	Copy files from one directory to another. More...
template<class Select , class Descend >
void	copyFilesRecursively (const Path &root, const Path &destination, Select select, Descend descend)
	Recursively copy files. More...
ROSE_UTIL_API std::vector< Path >	findRoseFilesRecursively (const Path &root)
	Return a list of all rose_* files.
ROSE_UTIL_API std::string	toString (const Path &)
	Convert a path to a string. More...
template<class Container >
Container	readFile (const boost::filesystem::path &fileName, std::ios_base::openmode openMode=std::ios_base::in|std::ios_base::binary)
	Load an entire file into an STL container.
template<class Container >
void	writeFile (const boost::filesystem::path &fileName, const Container &data, std::ios_base::openmode openMode=std::ios_base::out|std::ios_base::binary)

Variables
const char *	tempNamePattern
	Pattern to use when creating temporary files.

Function Documentation

createTemporaryDirectory()

ROSE_UTIL_API Path Rose::FileSystem::createTemporaryDirectory

(

)

Create a temporary directory.

The temporary directory is created as a subdirectory of the directory which is suitable for temporary files under the conventions of the operating system. The specifics of how this path is determined are implementation defined (see boost::filesystem::temp_directory_path). The created subdirectory has a name of the form "rose-%%%%%%%%-%%%%%%%%" where each "%" is a random hexadecimal digit. Returns the path to this directory.

makeNormal()

ROSE_UTIL_API Path Rose::FileSystem::makeNormal

(

const Path &

)

Normalize a path name.

Normalizes a path by removing "." and ".." components to the extent which is possible.

For instance, a name like "/foo/bar/../baz" will become "/foo/baz" and the name "/foo/./baz" will become "/foo/baz". However, the names "/../foo" and "./foo" cannot be changed because removing the ".." in the first case would place it in a different directory if the name were appended to another name, and in the second case it would convert a relative name to an absolute name.

makeRelative()

ROSE_UTIL_API Path Rose::FileSystem::makeRelative	(	const Path &	path,
		const Path &	root = boost::filesystem::current_path()
	)

Make path relative.

Makes the specified path relative to another path or the current working directory.

makeAbsolute()

ROSE_UTIL_API Path Rose::FileSystem::makeAbsolute	(	const Path &	path,
		const Path &	root = boost::filesystem::current_path()
	)

Make path absolute.

Makes the specified path an absolute path if it is a relative path. If relative, then assume root is what the path is relative to.

findNames() [1/2]

template<class Select >

std::vector<Path> Rose::FileSystem::findNames	(	const Path &	root,
		Select	select
	)

Entries within a directory.

Returns a list of entries in a directory–the contents of a directory–without recursing into subdirectories. The return value is a sorted list of paths, each of which contains root as a prefix. If a select predicate is supplied then only paths for which the predicate returns true become part of the return value. The predicate is called with the path that would become part of the return value. The root itself is never returned and never tested by the predicate.

If select is not specified then all entries are returned.

Definition at line 106 of file Rose/FileSystem.h.

References isDirectory().

Here is the call graph for this function:

findNames() [2/2]

ROSE_UTIL_API std::vector<Path> Rose::FileSystem::findNames

(

const Path &

root

)

Entries within a directory.

Returns a list of entries in a directory–the contents of a directory–without recursing into subdirectories. The return value is a sorted list of paths, each of which contains root as a prefix. If a select predicate is supplied then only paths for which the predicate returns true become part of the return value. The predicate is called with the path that would become part of the return value. The root itself is never returned and never tested by the predicate.

If select is not specified then all entries are returned.

findNamesRecursively() [1/3]

template<class Select , class Descend >

std::vector<Path> Rose::FileSystem::findNamesRecursively	(	const Path &	root,
		Select	select,
		Descend	descend
	)

Recursive list of names satisfying predicate.

Returns a list of entries in a directory and all subdirectories recursively. The return value is a sorted list of paths, each of which contains root as a prefix. If a select predicate is supplied then only paths for which the predicate returns true become part of the return value. If a descend predicate is supplied then this algorithm only recurses into subdirectories for which descend returns true. The predicates are called with the path that would become part of the return value. The root itself is never returned and never tested by the select or descend predicates.

If select is not specified then all entries are returned. If descend is not specified then the algorithm traverses into all subdirectories. Symbolic links to directories are never followed, but are returned if the select predicate allows them.

Definition at line 135 of file Rose/FileSystem.h.

Referenced by copyFilesRecursively(), and findNamesRecursively().

Here is the caller graph for this function:

findNamesRecursively() [2/3]

template<class Select >

std::vector<Path> Rose::FileSystem::findNamesRecursively	(	const Path &	root,
		Select	select
	)

Recursive list of names satisfying predicate.

Returns a list of entries in a directory and all subdirectories recursively. The return value is a sorted list of paths, each of which contains root as a prefix. If a select predicate is supplied then only paths for which the predicate returns true become part of the return value. If a descend predicate is supplied then this algorithm only recurses into subdirectories for which descend returns true. The predicates are called with the path that would become part of the return value. The root itself is never returned and never tested by the select or descend predicates.

If select is not specified then all entries are returned. If descend is not specified then the algorithm traverses into all subdirectories. Symbolic links to directories are never followed, but are returned if the select predicate allows them.

Definition at line 149 of file Rose/FileSystem.h.

References findNamesRecursively(), and isDirectory().

Here is the call graph for this function:

findNamesRecursively() [3/3]

ROSE_UTIL_API std::vector<Path> Rose::FileSystem::findNamesRecursively

(

const Path &

root

)

Recursive list of names satisfying predicate.

Returns a list of entries in a directory and all subdirectories recursively. The return value is a sorted list of paths, each of which contains root as a prefix. If a select predicate is supplied then only paths for which the predicate returns true become part of the return value. If a descend predicate is supplied then this algorithm only recurses into subdirectories for which descend returns true. The predicates are called with the path that would become part of the return value. The root itself is never returned and never tested by the select or descend predicates.

If select is not specified then all entries are returned. If descend is not specified then the algorithm traverses into all subdirectories. Symbolic links to directories are never followed, but are returned if the select predicate allows them.

copyFile()

ROSE_UTIL_API void Rose::FileSystem::copyFile	(	const Path &	sourceFileName,
		const Path &	destinationFileName
	)

Copy a file.

Copies the contents of the source file to the destination file, overwriting the destination file if it existed.

copyFiles()

ROSE_UTIL_API void Rose::FileSystem::copyFiles	(	const std::vector< Path > &	files,
		const Path &	root,
		const Path &	destinationDirectory
	)

Copy files from one directory to another.

Each of the specified files are copied from their location under root to a similar location under destinationDirectory. Subdirectories of the destination directory are created as necessary.

Any file whose name is outside the root directory will similarly be created outside the destinationDirectory. For instance, copyFiles(["bar/baz"], "foo", "frob") will copy "bar/baz" to "frob/../bar/baz" since "bar" is apparently a sibling of "foo", and therefore must be a sibling of "frob".

Throws a boost::filesystem::filesystem_error on failure.

Referenced by copyFilesRecursively().

Here is the caller graph for this function:

copyFilesRecursively()

template<class Select , class Descend >

void Rose::FileSystem::copyFilesRecursively	(	const Path &	root,
		const Path &	destination,
		Select	select,
		Descend	descend
	)

Recursively copy files.

Get a list of files by recursively matching files under root and then copy them to similar locations relative to destination. The root and destination must not overlap. The select and descend arguments are the same as for the findAllNames method.

Definition at line 179 of file Rose/FileSystem.h.

References copyFiles(), findNamesRecursively(), and isFile().

Here is the call graph for this function:

toString()

ROSE_UTIL_API std::string Rose::FileSystem::toString

(

const Path &

)

Convert a path to a string.

Try not to use this. Paths contain more information than std::string and the conversion may loose that info.