#include <filesystem.h>

Inheritance diagram for foobar2000_io::filesystem:

Public Types
enum	t_open_mode { open_mode_read, open_mode_write_existing, open_mode_write_new }

Public Types inherited from service_base
typedef service_base	t_interface

Public Member Functions
void	copy_directory (const char p_src, const char p_dst, abort_callback &p_abort)

virtual void	create_directory (const char *p_path, abort_callback &p_abort)=0

virtual bool	get_canonical_path (const char *p_path, pfc::string_base &p_out)=0

virtual bool	get_display_path (const char *p_path, pfc::string_base &p_out)=0

virtual void	get_stats (const char *p_path, t_filestats &p_stats, bool &p_is_writeable, abort_callback &p_abort)=0

virtual bool	is_our_path (const char *p_path)=0

virtual bool	is_remote (const char *p_src)=0

virtual void	list_directory (const char *p_path, directory_callback &p_out, abort_callback &p_abort)=0

virtual void	move (const char p_src, const char p_dst, abort_callback &p_abort)=0

virtual void	open (service_ptr_t< file > &p_out, const char *p_path, t_open_mode p_mode, abort_callback &p_abort)=0

virtual bool	relative_path_create (const char file_path, const char playlist_path, pfc::string_base &out)

virtual bool	relative_path_parse (const char relative_path, const char playlist_path, pfc::string_base &out)

virtual void	remove (const char *p_path, abort_callback &p_abort)=0

void	remove_directory_content (const char *path, abort_callback &abort)

void	remove_object_recur (const char *path, abort_callback &abort)

virtual bool	supports_content_types ()=0

Public Member Functions inherited from service_base
template<typename outPtr_t >
bool	cast (outPtr_t &outPtr)

virtual int	service_add_ref ()=0 throw ()

virtual bool	service_query (service_ptr_t< service_base > &p_out, const GUID &p_guid)

template<class T >
bool	service_query_t (service_ptr_t< T > &p_out)

virtual int	service_release ()=0 throw ()

Static Public Member Functions
static void	g_copy (const char p_src, const char p_dst, abort_callback &p_abort)

static void	g_copy_directory (const char p_src, const char p_dst, abort_callback &p_abort)

static void	g_copy_timeout (const char p_src, const char p_dst, double p_timeout, abort_callback &p_abort)

static void	g_create_directory (const char *p_path, abort_callback &p_abort)

static bool	g_exists (const char *p_path, abort_callback &p_abort)

static bool	g_exists_writeable (const char *p_path, abort_callback &p_abort)

static void	g_get_canonical_path (const char *path, pfc::string_base &out)

static void	g_get_display_path (const char *path, pfc::string_base &out)

static bool	g_get_interface (service_ptr_t< filesystem > &p_out, const char *path)

static filesystem::ptr	g_get_interface (const char *path)

static bool	g_get_native_path (const char *path, pfc::string_base &out)

static void	g_get_stats (const char *p_path, t_filestats &p_stats, bool &p_is_writeable, abort_callback &p_abort)

static bool	g_is_empty_directory (const char *path, abort_callback &p_abort)

static bool	g_is_recognized_and_remote (const char *p_path)

static bool	g_is_recognized_path (const char *p_path)

static bool	g_is_remote (const char *p_path)

static bool	g_is_remote_or_unrecognized (const char *p_path)

static bool	g_is_remote_safe (const char *p_path)

static bool	g_is_valid_directory (const char *path, abort_callback &p_abort)

static void	g_link (const char p_src, const char p_dst, abort_callback &p_abort)

static void	g_link_timeout (const char p_src, const char p_dst, double p_timeout, abort_callback &p_abort)

static void	g_list_directory (const char *p_path, directory_callback &p_out, abort_callback &p_abort)

static void	g_move (const char p_src, const char p_dst, abort_callback &p_abort)

static void	g_move_timeout (const char p_src, const char p_dst, double p_timeout, abort_callback &p_abort)

static void	g_open (service_ptr_t< file > &p_out, const char *p_path, t_open_mode p_mode, abort_callback &p_abort)

static void	g_open_precache (service_ptr_t< file > &p_out, const char *path, abort_callback &p_abort)

static void	g_open_read (service_ptr_t< file > &p_out, const char *path, abort_callback &p_abort)

static void	g_open_temp (service_ptr_t< file > &p_out, abort_callback &p_abort)

static void	g_open_tempmem (service_ptr_t< file > &p_out, abort_callback &p_abort)

static file::ptr	g_open_tempmem ()

static void	g_open_timeout (service_ptr_t< file > &p_out, const char *p_path, t_open_mode p_mode, double p_timeout, abort_callback &p_abort)

static void	g_open_write_new (service_ptr_t< file > &p_out, const char *p_path, abort_callback &p_abort)

static bool	g_relative_path_create (const char p_file_path, const char p_playlist_path, pfc::string_base &out)

static bool	g_relative_path_parse (const char p_relative_path, const char p_playlist_path, pfc::string_base &out)

static void	g_remove (const char *p_path, abort_callback &p_abort)

static void	g_remove_object_recur (const char *path, abort_callback &abort)

static void	g_remove_object_recur_timeout (const char *path, double timeout, abort_callback &abort)

static void	g_remove_timeout (const char *p_path, double p_timeout, abort_callback &p_abort)

static FILE *	streamio_open (const char p_path, const char p_flags)

Private Member Functions
	FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT (filesystem)

Additional Inherited Members
Protected Member Functions inherited from service_base
	service_base ()

	~service_base ()

Detailed Description

Entrypoint service for all filesystem operations.
Implementation: standard implementations for local filesystem etc are provided by core.
Instantiation: use static helper functions rather than calling filesystem interface methods directly, e.g. filesystem::g_open() to open a file.

Definition at line 383 of file filesystem.h.

Member Enumeration Documentation

enum foobar2000_io::filesystem::t_open_mode

Enumeration specifying how to open a file. See: filesystem::open(), filesystem::g_open().

Enumerator
open_mode_read	Opens an existing file for reading; if the file does not exist, the operation will fail.
open_mode_write_existing	Opens an existing file for writing; if the file does not exist, the operation will fail.
open_mode_write_new	Opens a new file for writing; if the file exists, its contents will be wiped.

Definition at line 387 of file filesystem.h.

                          {
             open_mode_read,
             open_mode_write_existing,
             open_mode_write_new,
         };

Member Function Documentation

void filesystem::copy_directory	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

Definition at line 553 of file filesystem.cpp.

                                                                                             {
     try {
         this->create_directory( dst, p_abort );
     } catch(exception_io_already_exists) {}
     directory_callback_impl_copy cb(dst, this);
     list_directory(src, cb, p_abort);
 }

virtual void foobar2000_io::filesystem::create_directory	(	const char *	p_path,
		abort_callback &	p_abort
	)

pure virtual

Creates a directory.

Implemented in foobar2000_io::archive_impl.

foobar2000_io::filesystem::FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT ( filesystem )

private

void filesystem::g_copy	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

static

Definition at line 570 of file filesystem.cpp.

                                                                                   {
     service_ptr_t<file> r_src,r_dst;
     t_filesize size;
 
     g_open(r_src,src,open_mode_read,p_abort);
     size = r_src->get_size_ex(p_abort);
     g_open(r_dst,dst,open_mode_write_new,p_abort);
     
     if (size > 0) {
         try {
             file::g_transfer_object(r_src,r_dst,size,p_abort);
         } catch(...) {
             r_dst.release();
             abort_callback_dummy dummy;
             try {g_remove(dst,dummy);} catch(...) {}
             throw;
         }
     }
 }

void filesystem::g_copy_directory	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

static

Definition at line 561 of file filesystem.cpp.

                                                                                             {
     filesystem::ptr dstFS = filesystem::g_get_interface(dst);
     try {
         dstFS->create_directory( dst, p_abort );
     } catch(exception_io_already_exists) {}
     directory_callback_impl_copy cb(dst, dstFS);
     g_list_directory(src,cb,p_abort);
 }

void filesystem::g_copy_timeout	(	const char *	p_src,
		const char *	p_dst,
		double	p_timeout,
		abort_callback &	p_abort
	)

static

Definition at line 179 of file filesystem.cpp.

                                                                                                                {
     FB2K_RETRY_FILE_MOVE( g_copy(p_src, p_dst, p_abort), p_abort, p_timeout );
 }

void filesystem::g_create_directory	(	const char *	p_path,
		abort_callback &	p_abort
	)

static

Definition at line 183 of file filesystem.cpp.

 {
     g_get_interface(p_path)->create_directory(p_path,p_abort);
 }

bool filesystem::g_exists	(	const char *	p_path,
		abort_callback &	p_abort
	)

static

Definition at line 147 of file filesystem.cpp.

 {
     t_filestats stats;
     bool dummy;
     try {
         g_get_stats(p_path,stats,dummy,p_abort);
     } catch(exception_io_not_found) {return false;}
     return true;
 }

bool filesystem::g_exists_writeable	(	const char *	p_path,
		abort_callback &	p_abort
	)

static

Definition at line 157 of file filesystem.cpp.

 {
     t_filestats stats;
     bool writeable;
     try {
         g_get_stats(p_path,stats,writeable,p_abort);
     } catch(exception_io_not_found) {return false;}
     return writeable;
 }

void filesystem::g_get_canonical_path	(	const char *	path,
		pfc::string_base &	out
	)

static

Definition at line 74 of file filesystem.cpp.

 {
     TRACK_CALL_TEXT("filesystem::g_get_canonical_path");
 
     service_enum_t<filesystem> e;
     service_ptr_t<filesystem> ptr;
     if (e.first(ptr)) do {
         if (ptr->get_canonical_path(path,out)) return;
     } while(e.next(ptr));
     //no one wants to process this, let's copy over
     out = path;
 }

void filesystem::g_get_display_path	(	const char *	path,
		pfc::string_base &	out
	)

static

Definition at line 87 of file filesystem.cpp.

 {
     TRACK_CALL_TEXT("filesystem::g_get_display_path");
     service_ptr_t<filesystem> ptr;
     if (!g_get_interface(ptr,path))
     {
         //no one wants to process this, let's copy over
         out = path;
     }
     else
     {
         if (!ptr->get_display_path(path,out))
             out = path;
     }
 }

bool filesystem::g_get_interface	(	service_ptr_t< filesystem > &	p_out,
		const char *	path
	)

static

Definition at line 121 of file filesystem.cpp.

 {
     service_enum_t<filesystem> e;
     service_ptr_t<filesystem> ptr;
     if (e.first(ptr)) do {
         if (ptr->is_our_path(path))
         {
             p_out = ptr;
             return true;
         }
     } while(e.next(ptr));
     return false;
 }

filesystem::ptr filesystem::g_get_interface ( const char * path )

static

Definition at line 115 of file filesystem.cpp.

                                                            {
     filesystem::ptr rv;
     if (!g_get_interface(rv, path)) throw exception_io_no_handler_for_path();
     return rv;
 
 }

bool filesystem::g_get_native_path	(	const char *	path,
		pfc::string_base &	out
	)

static

Extracts the native filesystem path, sets out to the input path if native path cannot be extracted so the output is always set.

Returns: True if native path was extracted successfully, false otherwise (but output is set anyway).

Definition at line 103 of file filesystem.cpp.

                                                                            {
     // Is proper file:// path?
     if (foobar2000_io::extract_native_path( path, out ) ) return true;
 
     // Set anyway
     out = path;
     
     // Maybe just a file:// less local path? Check for other protocol markers
     // If no :// present, return true anyway
     return strstr( path, "://" ) == NULL;
 }

void filesystem::g_get_stats	(	const char *	p_path,
		t_filestats &	p_stats,
		bool &	p_is_writeable,
		abort_callback &	p_abort
	)

static

Definition at line 659 of file filesystem.cpp.

                                                                                                                      {
     TRACK_CALL_TEXT("filesystem::g_get_stats");
     return g_get_interface(p_path)->get_stats(p_path,p_stats,p_is_writeable,p_abort);
 }

bool filesystem::g_is_empty_directory	(	const char *	path,
		abort_callback &	p_abort
	)

static

Definition at line 471 of file filesystem.cpp.

 {
     directory_callback_isempty callback;
     try {
         g_list_directory(path,callback,p_abort);
     } catch(exception_io const &) {return false;}
     return callback.isempty();
 }

bool filesystem::g_is_recognized_and_remote ( const char * p_path )

static

Definition at line 258 of file filesystem.cpp.

                                                                {
     service_ptr_t<filesystem> fs;
     if (g_get_interface(fs,p_path)) return fs->is_remote(p_path);
     else return false;
 }

bool filesystem::g_is_recognized_path ( const char * p_path )

static

Definition at line 847 of file filesystem.cpp.

                                                          {
     filesystem::ptr obj;
     return g_get_interface(obj,p_path);
 }

bool filesystem::g_is_remote ( const char * p_path )

static

Definition at line 254 of file filesystem.cpp.

                                                 {
     return g_get_interface(p_path)->is_remote(p_path);
 }

bool filesystem::g_is_remote_or_unrecognized ( const char * p_path )

static

Definition at line 264 of file filesystem.cpp.

                                                                 {
     service_ptr_t<filesystem> fs;
     if (g_get_interface(fs,p_path)) return fs->is_remote(p_path);
     else return true;
 }

static bool foobar2000_io::filesystem::g_is_remote_safe ( const char * p_path )

inlinestatic

Definition at line 431 of file filesystem.h.

431 {return g_is_recognized_and_remote(p_path);}

foobar2000_io::filesystem::g_is_recognized_and_remote

static bool g_is_recognized_and_remote(const char *p_path)

Definition: filesystem.cpp:258

bool filesystem::g_is_valid_directory	(	const char *	path,
		abort_callback &	p_abort
	)

static

Definition at line 480 of file filesystem.cpp.

                                                                                 {
     try {
         directory_callback_dummy cb;
         g_list_directory(path,cb,p_abort);
         return true;
     } catch(exception_io const &) {return false;}
 }

void filesystem::g_link	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

static

Definition at line 200 of file filesystem.cpp.

                                                                                       {
     if (!foobar2000_io::_extract_native_path_ptr(p_src) || !foobar2000_io::_extract_native_path_ptr(p_dst)) throw exception_io_no_handler_for_path();
     WIN32_IO_OP( CreateHardLink( pfc::stringcvt::string_os_from_utf8( p_dst ), pfc::stringcvt::string_os_from_utf8( p_src ), NULL) );
 }

void filesystem::g_link_timeout	(	const char *	p_src,
		const char *	p_dst,
		double	p_timeout,
		abort_callback &	p_abort
	)

static

Definition at line 205 of file filesystem.cpp.

                                                                                                                {
     FB2K_RETRY_FILE_MOVE( g_link(p_src, p_dst, p_abort), p_abort, p_timeout );
 }

void filesystem::g_list_directory	(	const char *	p_path,
		directory_callback &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 210 of file filesystem.cpp.

 {
     TRACK_CALL_TEXT("filesystem::g_list_directory");
     g_get_interface(p_path)->list_directory(p_path,p_out,p_abort);
 }

void filesystem::g_move	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

static

Moves file from one path to another.

Definition at line 188 of file filesystem.cpp.

                                                                                   {
     service_enum_t<filesystem> e;
     service_ptr_t<filesystem> ptr;
     if (e.first(ptr)) do {
         if (ptr->is_our_path(src) && ptr->is_our_path(dst)) {
             ptr->move(src,dst,p_abort);
             return;
         }
     } while(e.next(ptr));
     throw exception_io_no_handler_for_path();
 }

void filesystem::g_move_timeout	(	const char *	p_src,
		const char *	p_dst,
		double	p_timeout,
		abort_callback &	p_abort
	)

static

Attempts to move file from one path to another; if the operation fails with a sharing violation error, keeps retrying (with short sleep period between retries) for specified amount of time.

Definition at line 175 of file filesystem.cpp.

                                                                                                                {
     FB2K_RETRY_FILE_MOVE( g_move(p_src, p_dst, p_abort), p_abort, p_timeout );
 }

void filesystem::g_open	(	service_ptr_t< file > &	p_out,
		const char *	p_path,
		t_open_mode	p_mode,
		abort_callback &	p_abort
	)

static

Opens file at specified path, with specified access privileges.

Definition at line 136 of file filesystem.cpp.

 {
     TRACK_CALL_TEXT("filesystem::g_open");
     g_get_interface(path)->open(p_out,path,mode,p_abort);
 }

void filesystem::g_open_precache	(	service_ptr_t< file > &	p_out,
		const char *	path,
		abort_callback &	p_abort
	)

static

Definition at line 248 of file filesystem.cpp.

                                                                                                          {
     service_ptr_t<filesystem> fs = g_get_interface(p_path);
     if (fs->is_remote(p_path)) throw exception_io_object_is_remote();
     fs->open(p_out,p_path,open_mode_read,p_abort);
 }

static void foobar2000_io::filesystem::g_open_read	(	service_ptr_t< file > &	p_out,
		const char *	path,
		abort_callback &	p_abort
	)

inlinestatic

Definition at line 440 of file filesystem.h.

440 {return g_open(p_out,path,open_mode_read,p_abort);}

foobar2000_io::filesystem::g_open

static void g_open(service_ptr_t< file > &p_out, const char *p_path, t_open_mode p_mode, abort_callback &p_abort)

Opens file at specified path, with specified access privileges.

Definition: filesystem.cpp:136

foobar2000_io::filesystem::open_mode_read

Opens an existing file for reading; if the file does not exist, the operation will fail...

Definition: filesystem.h:389

void filesystem::g_open_temp	(	service_ptr_t< file > &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 638 of file filesystem.cpp.

                                                                                  {
     g_open(p_out,"tempfile://",open_mode_write_new,p_abort);
 }

void filesystem::g_open_tempmem	(	service_ptr_t< file > &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 642 of file filesystem.cpp.

                                                                                     {
     g_open(p_out,"tempmem://",open_mode_write_new,p_abort);
 }

file::ptr filesystem::g_open_tempmem ( )

static

Definition at line 646 of file filesystem.cpp.

                                    {
     abort_callback_dummy aborter;
     file::ptr f; g_open_tempmem(f, aborter); return f;
 }

void filesystem::g_open_timeout	(	service_ptr_t< file > &	p_out,
		const char *	p_path,
		t_open_mode	p_mode,
		double	p_timeout,
		abort_callback &	p_abort
	)

static

Attempts to open file at specified path; if the operation fails with sharing violation error, keeps retrying (with short sleep period between retries) for specified amount of time.

Definition at line 143 of file filesystem.cpp.

                                                                                                                                             {
     FB2K_RETRY_ON_SHARING_VIOLATION( g_open(p_out, p_path, p_mode, p_abort), p_abort, p_timeout);
 }

void filesystem::g_open_write_new	(	service_ptr_t< file > &	p_out,
		const char *	p_path,
		abort_callback &	p_abort
	)

static

Definition at line 622 of file filesystem.cpp.

                                                                                                           {
     g_open(p_out,p_path,open_mode_write_new,p_abort);
 }

bool filesystem::g_relative_path_create	(	const char *	p_file_path,
		const char *	p_playlist_path,
		pfc::string_base &	out
	)

static

Definition at line 270 of file filesystem.cpp.

 {
     
     bool rv = false;
     service_ptr_t<filesystem> fs;
 
     if (g_get_interface(fs,file_path))
         rv = fs->relative_path_create(file_path,playlist_path,out);
     
     return rv;
 }

bool filesystem::g_relative_path_parse	(	const char *	p_relative_path,
		const char *	p_playlist_path,
		pfc::string_base &	out
	)

static

Definition at line 282 of file filesystem.cpp.

 {
     service_enum_t<filesystem> e;
     service_ptr_t<filesystem> ptr;
     if (e.first(ptr)) do {
         if (ptr->relative_path_parse(relative_path,playlist_path,out)) return true;
     } while(e.next(ptr));
     return false;
 }

void filesystem::g_remove	(	const char *	p_path,
		abort_callback &	p_abort
	)

static

Removes file at specified path.

Definition at line 167 of file filesystem.cpp.

                                                                       {
     g_get_interface(p_path)->remove(p_path,p_abort);
 }

void filesystem::g_remove_object_recur	(	const char *	path,
		abort_callback &	abort
	)

static

Definition at line 1003 of file filesystem.cpp.

                                                                                 {
     g_get_interface(path)->remove_object_recur(path, abort);
 }

void filesystem::g_remove_object_recur_timeout	(	const char *	path,
		double	timeout,
		abort_callback &	abort
	)

static

Definition at line 999 of file filesystem.cpp.

                                                                                                         {
     FB2K_RETRY_FILE_MOVE( g_remove_object_recur(path, abort), abort, timeout );
 }

void filesystem::g_remove_timeout	(	const char *	p_path,
		double	p_timeout,
		abort_callback &	p_abort
	)

static

Attempts to remove file at specified path; if the operation fails with a sharing violation error, keeps retrying (with short sleep period between retries) for specified amount of time.

Definition at line 171 of file filesystem.cpp.

                                                                                                {
     FB2K_RETRY_FILE_MOVE( g_remove(p_path, p_abort), p_abort, p_timeout );
 }

virtual bool foobar2000_io::filesystem::get_canonical_path	(	const char *	p_path,
		pfc::string_base &	p_out
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual bool foobar2000_io::filesystem::get_display_path	(	const char *	p_path,
		pfc::string_base &	p_out
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual void foobar2000_io::filesystem::get_stats	(	const char *	p_path,
		t_filestats &	p_stats,
		bool &	p_is_writeable,
		abort_callback &	p_abort
	)

pure virtual

Retrieves stats of a file at specified path.

Implemented in foobar2000_io::archive_impl.

virtual bool foobar2000_io::filesystem::is_our_path ( const char * p_path )

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual bool foobar2000_io::filesystem::is_remote ( const char * p_src )

pure virtual

Queries whether a file at specified path belonging to this filesystem is a remove object or not.

Implemented in foobar2000_io::archive_impl.

virtual void foobar2000_io::filesystem::list_directory	(	const char *	p_path,
		directory_callback &	p_out,
		abort_callback &	p_abort
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual void foobar2000_io::filesystem::move	(	const char *	p_src,
		const char *	p_dst,
		abort_callback &	p_abort
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual void foobar2000_io::filesystem::open	(	service_ptr_t< file > &	p_out,
		const char *	p_path,
		t_open_mode	p_mode,
		abort_callback &	p_abort
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

virtual bool foobar2000_io::filesystem::relative_path_create	(	const char *	file_path,
		const char *	playlist_path,
		pfc::string_base &	out
	)

inlinevirtual

Reimplemented in foobar2000_io::archive_impl.

Definition at line 409 of file filesystem.h.

409 {return false;}

virtual bool foobar2000_io::filesystem::relative_path_parse	(	const char *	relative_path,
		const char *	playlist_path,
		pfc::string_base &	out
	)

inlinevirtual

Reimplemented in foobar2000_io::archive_impl.

Definition at line 410 of file filesystem.h.

410 {return false;}

virtual void foobar2000_io::filesystem::remove	(	const char *	p_path,
		abort_callback &	p_abort
	)

pure virtual

Implemented in foobar2000_io::archive_impl.

void filesystem::remove_directory_content	(	const char *	path,
		abort_callback &	abort
	)

Definition at line 978 of file filesystem.cpp.

                                                                                    {
     class myCallback : public directory_callback {
     public:
         bool on_entry(filesystem * p_owner,abort_callback & p_abort,const char * p_url,bool p_is_subdirectory,const t_filestats & p_stats) {
             if (p_is_subdirectory) p_owner->list_directory(p_url, *this, p_abort);
             try {
                 p_owner->remove(p_url, p_abort);
             } catch(exception_io_not_found) {}
             return true;
         }
     };
     myCallback cb;
     list_directory(path, cb, abort);
 }

void filesystem::remove_object_recur	(	const char *	path,
		abort_callback &	abort
	)

Definition at line 992 of file filesystem.cpp.

                                                                               {
     try {
         remove_directory_content(path, abort);
     } catch(exception_io_not_found) {}
     remove(path, abort);
 }

FILE * filesystem::streamio_open	(	const char *	p_path,
		const char *	p_flags
	)

static

If for some bloody reason you ever need stream io compatibility, use this, INSTEAD of calling fopen() on the path string you've got; will only work with file:// (and not with http://, unpack:// or whatever)

Definition at line 435 of file filesystem.cpp.

 {
     FILE * ret = 0;
     pfc::string8 temp;
     g_get_canonical_path(path,temp);
     if (!strncmp(temp,"file://",7))
     {
         ret = _wfopen(pfc::stringcvt::string_wide_from_utf8(path+7),pfc::stringcvt::string_wide_from_utf8(flags));
     }
     return ret;
 }

virtual bool foobar2000_io::filesystem::supports_content_types ( )

pure virtual

Hint; returns whether this filesystem supports mime types.
When this returns false, all file::get_content_type() calls on files opened thru this filesystem implementation will return false; otherwise, file::get_content_type() calls may return true depending on the file.

The documentation for this class was generated from the following files:

foobar2000/SDK/filesystem.h
foobar2000/SDK/filesystem.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Member Function Documentation