Data Structures
class	abort_callback

class	abort_callback_dummy

class	abort_callback_impl

class	archive

class	archive_callback

class	archive_factory_t

class	archive_impl

class	directory_callback

class	directory_callback_impl

class	directory_callback_retrieveList

class	directory_callback_retrieveListEx

class	directory_callback_retrieveListRecur

class	file

class	file_cached

class	file_dynamicinfo

class	file_readonly_t

class	file_streamstub

class	filesystem

class	format_filetimestamp

class	format_filetimestamp_utc

class	stream_reader

class	stream_writer

struct	t_filestats

Typedefs
typedef abort_callback_impl	abort_callback_dummy

typedef pfc::eventHandle_t	abort_callback_event

typedef service_ptr_t< file >	file_ptr

typedef file_readonly_t< file >	file_readonly

typedef t_uint64	t_filesize

typedef t_uint64	t_filetimestamp

typedef t_int64	t_sfilesize

Functions
bool	_extract_native_path_ptr (const char *&p_fspath)

PFC_NORETURN void	exception_io_from_win32 (DWORD p_code)

bool	extract_native_path (const char *p_fspath, pfc::string_base &p_native)

bool	extract_native_path_ex (const char *p_fspath, pfc::string_base &p_native)

file_ptr	fileOpen (const char *p_path, filesystem::t_open_mode p_mode, abort_callback &p_abort, double p_timeout)

file_ptr	fileOpenReadExisting (const char *p_path, abort_callback &p_abort, double p_timeout=0)

file_ptr	fileOpenWriteExisting (const char *p_path, abort_callback &p_abort, double p_timeout=0)

file_ptr	fileOpenWriteNew (const char *p_path, abort_callback &p_abort, double p_timeout=0)

t_filetimestamp	filetimestamp_from_string (const char *date)

t_filetimestamp	filetimestamp_from_system_timer ()

void	generate_temp_location_for_file (pfc::string_base &p_out, const char p_origpath, const char p_extension, const char *p_magic)

template<typename T >
pfc::string	getPathCanonical (const T &source)

template<typename T >
pfc::string	getPathDisplay (const T &source)

t_filetimestamp	import_filetimestamp (FILETIME ft)

bool	is_native_filesystem (const char *p_fspath)

template<typename t_list >
static void	listDirectories (const char *p_path, t_list &p_out, abort_callback &p_abort)

template<typename t_list >
static void	listFiles (const char *p_path, t_list &p_out, abort_callback &p_abort)

template<typename t_list >
static void	listFilesAndDirectories (const char *p_path, t_list &p_files, t_list &p_directories, abort_callback &p_abort)

template<typename t_list >
static void	listFilesRecur (const char *p_path, t_list &p_out, abort_callback &p_abort)

bool	matchContentType (const char fullString, const char ourType)

bool	matchProtocol (const char fullString, const char protocolName)

	PFC_DECLARE_EXCEPTION (exception_aborted, pfc::exception,"User abort")

	PFC_DECLARE_EXCEPTION (exception_io, pfc::exception,"I/O error")

	PFC_DECLARE_EXCEPTION (exception_io_not_found, exception_io,"Object not found")

	PFC_DECLARE_EXCEPTION (exception_io_denied, exception_io,"Access denied")

	PFC_DECLARE_EXCEPTION (exception_io_denied_readonly, exception_io_denied,"File is read-only")

	PFC_DECLARE_EXCEPTION (exception_io_data, exception_io,"Unsupported format or corrupted file")

	PFC_DECLARE_EXCEPTION (exception_io_data_truncation, exception_io_data,"Unsupported format or corrupted file")

	PFC_DECLARE_EXCEPTION (exception_io_unsupported_format, exception_io_data,"Unsupported file format")

	PFC_DECLARE_EXCEPTION (exception_io_object_is_remote, exception_io,"This operation is not supported on remote objects")

	PFC_DECLARE_EXCEPTION (exception_io_sharing_violation, exception_io,"File is already in use")

	PFC_DECLARE_EXCEPTION (exception_io_device_full, exception_io,"Device full")

	PFC_DECLARE_EXCEPTION (exception_io_seek_out_of_range, exception_io,"Seek offset out of range")

	PFC_DECLARE_EXCEPTION (exception_io_object_not_seekable, exception_io,"Object is not seekable")

	PFC_DECLARE_EXCEPTION (exception_io_no_length, exception_io,"Length of object is unknown")

	PFC_DECLARE_EXCEPTION (exception_io_no_handler_for_path, exception_io,"Invalid path")

	PFC_DECLARE_EXCEPTION (exception_io_already_exists, exception_io,"Object already exists")

	PFC_DECLARE_EXCEPTION (exception_io_no_data, exception_io,"The process receiving or sending data has terminated")

	PFC_DECLARE_EXCEPTION (exception_io_network_not_reachable, exception_io,"Network not reachable")

	PFC_DECLARE_EXCEPTION (exception_io_write_protected, exception_io_denied,"The media is write protected")

	PFC_DECLARE_EXCEPTION (exception_io_file_corrupted, exception_io,"The file is corrupted")

	PFC_DECLARE_EXCEPTION (exception_io_disk_change, exception_io,"Disc not available")

	PFC_DECLARE_EXCEPTION (exception_io_directory_not_empty, exception_io,"Directory not empty")

void	purgeOldFiles (const char *directory, t_filetimestamp period, abort_callback &abort)

void	substituteProtocol (pfc::string_base &out, const char fullString, const char protocolName)

PFC_NORETURN void	win32_file_write_failure (DWORD p_code, const char *path)

Variables
static const t_filesize	filesize_invalid = (t_filesize)(~0)

static const t_filestats	filestats_invalid = {filesize_invalid,filetimestamp_invalid}

static const t_filetimestamp	filetimestamp_1second_increment = 10000000

const t_filetimestamp	filetimestamp_invalid = 0

Detailed Description

Contains various I/O related structures and interfaces.

Typedef Documentation

typedef abort_callback_impl foobar2000_io::abort_callback_dummy

Definition at line 87 of file abort_callback.h.

typedef pfc::eventHandle_t foobar2000_io::abort_callback_event

Definition at line 8 of file abort_callback.h.

typedef service_ptr_t<file> foobar2000_io::file_ptr

Definition at line 319 of file filesystem.h.

typedef file_readonly_t<file> foobar2000_io::file_readonly

Definition at line 352 of file filesystem.h.

typedef t_uint64 foobar2000_io::t_filesize

Type used for file size related variables.

Definition at line 8 of file filesystem.h.

typedef t_uint64 foobar2000_io::t_filetimestamp

Type used for file timestamp related variables. 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601; 0 for invalid/unknown time.

Definition at line 12 of file filesystem.h.

typedef t_int64 foobar2000_io::t_sfilesize

Type used for file size related variables when a signed value is needed.

Definition at line 10 of file filesystem.h.

Function Documentation

bool foobar2000_io::_extract_native_path_ptr ( const char *& p_fspath )

Definition at line 942 of file filesystem.cpp.

                                                                     {
     static const char header[] = "file://"; static const t_size headerLen = 7;
     if (strncmp(p_fspath,header,headerLen) != 0) return false;
     p_fspath += headerLen;
     return true;
 }

PFC_NORETURN void foobar2000_io::exception_io_from_win32 ( DWORD p_code )

Definition at line 773 of file filesystem.cpp.

                                                                      {
     //pfc::string_fixed_t<32> debugMsg; debugMsg << "Win32 I/O error #" << (t_uint32)p_code;
     //TRACK_CALL_TEXT(debugMsg);
     switch(p_code) {
     case ERROR_ALREADY_EXISTS:
     case ERROR_FILE_EXISTS:
         throw exception_io_already_exists();
     case ERROR_NETWORK_ACCESS_DENIED:
     case ERROR_ACCESS_DENIED:
         throw exception_io_denied();
     case ERROR_WRITE_PROTECT:
         throw exception_io_write_protected();
     case ERROR_BUSY:
     case ERROR_PATH_BUSY:
     case ERROR_SHARING_VIOLATION:
     case ERROR_LOCK_VIOLATION:
         throw exception_io_sharing_violation();
     case ERROR_HANDLE_DISK_FULL:
     case ERROR_DISK_FULL:
         throw exception_io_device_full();
     case ERROR_FILE_NOT_FOUND:
     case ERROR_PATH_NOT_FOUND:
         throw exception_io_not_found();
     case ERROR_BROKEN_PIPE:
     case ERROR_NO_DATA:
         throw exception_io_no_data();
     case ERROR_NETWORK_UNREACHABLE:
     case ERROR_NETNAME_DELETED:
         throw exception_io_network_not_reachable();
     case ERROR_NOT_READY:
         throw exception_io_device_not_ready();
     case ERROR_INVALID_DRIVE:
         throw exception_io_invalid_drive();
     case ERROR_CRC:
     case ERROR_FILE_CORRUPT:
     case ERROR_DISK_CORRUPT:
         throw exception_io_file_corrupted();
     case ERROR_BUFFER_OVERFLOW:
         throw exception_io_buffer_overflow();
     case ERROR_DISK_CHANGE:
         throw exception_io_disk_change();
     case ERROR_DIR_NOT_EMPTY:
         throw exception_io_directory_not_empty();
     case ERROR_INVALID_NAME:
         throw exception_io_invalid_path_syntax();
     case ERROR_NO_SYSTEM_RESOURCES:
     case ERROR_NONPAGED_SYSTEM_RESOURCES:
     case ERROR_PAGED_SYSTEM_RESOURCES:
     case ERROR_WORKING_SET_QUOTA:
     case ERROR_PAGEFILE_QUOTA:
     case ERROR_COMMITMENT_LIMIT:
         throw exception_io("Insufficient system resources");
     case ERROR_IO_DEVICE:
         throw exception_io("Device error");
     default:
         throw exception_io_win32_ex(p_code);
     }
 }

bool foobar2000_io::extract_native_path	(	const char *	p_fspath,
		pfc::string_base &	p_native
	)

Definition at line 948 of file filesystem.cpp.

                                                                                        {
     if (!_extract_native_path_ptr(p_fspath)) return false;
     p_native = p_fspath;
     return true;
 }

bool foobar2000_io::extract_native_path_ex	(	const char *	p_fspath,
		pfc::string_base &	p_native
	)

Definition at line 954 of file filesystem.cpp.

                                                                                            {
     if (!_extract_native_path_ptr(p_fspath)) return false;
     if (p_fspath[0] != '\\' || p_fspath[1] != '\\') {
         p_native = "\\\\?\\";
         p_native += p_fspath;
     } else {
         p_native = p_fspath;
     }
     return true;
 }

file_ptr foobar2000_io::fileOpen	(	const char *	p_path,
		filesystem::t_open_mode	p_mode,
		abort_callback &	p_abort,
		double	p_timeout
	)

inline

Definition at line 571 of file filesystem.h.

                                                                                                                          {
         file_ptr temp; filesystem::g_open_timeout(temp,p_path,p_mode,p_timeout,p_abort); PFC_ASSERT(temp.is_valid()); return temp;
     }

file_ptr foobar2000_io::fileOpenReadExisting	(	const char *	p_path,
		abort_callback &	p_abort,
		double	p_timeout = `0`
	)

inline

Definition at line 575 of file filesystem.h.

                                                                                                             {
         return fileOpen(p_path,filesystem::open_mode_read,p_abort,p_timeout);
     }

file_ptr foobar2000_io::fileOpenWriteExisting	(	const char *	p_path,
		abort_callback &	p_abort,
		double	p_timeout = `0`
	)

inline

Definition at line 578 of file filesystem.h.

                                                                                                              {
         return fileOpen(p_path,filesystem::open_mode_write_existing,p_abort,p_timeout);
     }

file_ptr foobar2000_io::fileOpenWriteNew	(	const char *	p_path,
		abort_callback &	p_abort,
		double	p_timeout = `0`
	)

inline

Definition at line 581 of file filesystem.h.

                                                                                                         {
         return fileOpen(p_path,filesystem::open_mode_write_new,p_abort,p_timeout);
     }

t_filetimestamp foobar2000_io::filetimestamp_from_string ( const char * date )

Definition at line 27 of file filetimetools.cpp.

                                                                           {
     // Accepted format
     // YYYY-MM-DD HH:MM:SS
     try {
         t_size remaining = strlen(date);
         SYSTEMTIME st = {};
         st.wDay = 1; st.wMonth = 1;
         for(;;) {
 #define ADVANCE(n) { PFC_ASSERT( remaining >= n); date += n; remaining -= n; }
 #define ADVANCE_TEST(n) { if (remaining < n) throw exception_time_error(); }
 #define PARSE(var, digits) { ADVANCE_TEST(digits); var = (WORD) ParseDateElem(date, digits); ADVANCE(digits) ; }
 #define TEST_END( durationIncrement ) 
 #define SKIP(c) { ADVANCE_TEST(1); if (date[0] != c) throw exception_time_error(); ADVANCE(1); }
 #define SKIP_SPACING() {while(remaining > 0 && is_spacing(*date)) ADVANCE(1);}
             SKIP_SPACING();
             PARSE( st.wYear, 4 ); if (st.wYear < 1601) throw exception_time_error();
             TEST_END(wYear); SKIP('-');
             PARSE( st.wMonth, 2 ); if (st.wMonth < 1 || st.wMonth > 12) throw exception_time_error();
             TEST_END(wMonth); SKIP('-');
             PARSE( st.wDay, 2); if (st.wDay < 1 || st.wDay > 31) throw exception_time_error();
             TEST_END(wDay); SKIP(' ');
             PARSE( st.wHour, 2); if (st.wHour >= 24) throw exception_time_error();
             TEST_END(wHour); SKIP(':');
             PARSE( st.wMinute, 2); if (st.wMinute >= 60) throw exception_time_error();
             TEST_END(wMinute); SKIP(':');
             PARSE( st.wSecond, 2); if (st.wSecond >= 60) throw exception_time_error();
             SKIP_SPACING();
             TEST_END( wSecond );
 #undef ADVANCE
 #undef ADVANCE_TEST
 #undef PARSE
 #undef TEST_END
 #undef SKIP
 #undef SKIP_SPACING
             if (remaining > 0) throw exception_time_error();
             break;
         }
         t_filetimestamp base, out;
         if (!SystemTimeToFileTime(&st, (FILETIME*) &base)) throw exception_time_error();
         if (!LocalFileTimeToFileTime((const FILETIME*)&base, (FILETIME*)&out)) throw exception_time_error();
         return out;
     } catch(exception_time_error) {
         return filetimestamp_invalid;
     }
 }

t_filetimestamp foobar2000_io::filetimestamp_from_system_timer ( )

Definition at line 684 of file filesystem.cpp.

 {
     return pfc::fileTimeNow();
 }

void foobar2000_io::generate_temp_location_for_file	(	pfc::string_base &	p_out,
		const char *	p_origpath,
		const char *	p_extension,
		const char *	p_magic
	)

Definition at line 892 of file filesystem.cpp.

                                                                                                                                                  {
     hasher_md5_result hash;
     {
         static_api_ptr_t<hasher_md5> hasher;
         hasher_md5_state state;
         hasher->initialize(state);
         hasher->process(state,p_origpath,strlen(p_origpath));
         hasher->process(state,p_extension,strlen(p_extension));
         hasher->process(state,p_magic,strlen(p_magic));
         hash = hasher->get_result(state);
     }
 
     p_out = p_origpath;
     p_out.truncate(p_out.scan_filename());
     p_out += "temp-";
     p_out += pfc::format_hexdump(hash.m_data,sizeof(hash.m_data),"");
     p_out += ".";
     p_out += p_extension;
 }

template<typename T >

pfc::string foobar2000_io::getPathCanonical ( const T & source )

Definition at line 663 of file filesystem.h.

                                                 {
         pfc::string_formatter temp;
         filesystem::g_get_canonical_path(pfc::stringToPtr(source),temp);
         return temp.toString();
     }

template<typename T >

pfc::string foobar2000_io::getPathDisplay ( const T & source )

Definition at line 657 of file filesystem.h.

                                               {
         pfc::string_formatter temp;
         filesystem::g_get_display_path(pfc::stringToPtr(source),temp);
         return temp.toString();
     }

t_filetimestamp foobar2000_io::import_filetimestamp ( FILETIME ft )

inline

Definition at line 563 of file filesystem.h.

                                                              {
         return *reinterpret_cast<t_filetimestamp*>(&ft);
     }

bool foobar2000_io::is_native_filesystem ( const char * p_fspath )

Definition at line 938 of file filesystem.cpp.

                                                                 {
     return _extract_native_path_ptr( p_fspath );
 }

template<typename t_list >

static void foobar2000_io::listDirectories	(	const char *	p_path,
		t_list &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 636 of file filesystem.h.

                                                                                              {
         directory_callback_retrieveList<t_list> callback(p_out,false,true);
         filesystem::g_list_directory(p_path,callback,p_abort);
     }

template<typename t_list >

static void foobar2000_io::listFiles	(	const char *	p_path,
		t_list &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 631 of file filesystem.h.

                                                                                        {
         directory_callback_retrieveList<t_list> callback(p_out,true,false);
         filesystem::g_list_directory(p_path,callback,p_abort);
     }

template<typename t_list >

static void foobar2000_io::listFilesAndDirectories	(	const char *	p_path,
		t_list &	p_files,
		t_list &	p_directories,
		abort_callback &	p_abort
	)

static

Definition at line 641 of file filesystem.h.

                                                                                                                               {
         directory_callback_retrieveListEx<t_list> callback(p_files,p_directories);
         filesystem::g_list_directory(p_path,callback,p_abort);
     }

template<typename t_list >

static void foobar2000_io::listFilesRecur	(	const char *	p_path,
		t_list &	p_out,
		abort_callback &	p_abort
	)

static

Definition at line 646 of file filesystem.h.

                                                                                             {
         directory_callback_retrieveListRecur<t_list> callback(p_out);
         filesystem::g_list_directory(p_path,callback,p_abort);
     }

bool foobar2000_io::matchContentType	(	const char *	fullString,
		const char *	ourType
	)

Definition at line 1059 of file filesystem.cpp.

                                                                                   {
     t_size lim = pfc::string_find_first(fullString, ';');
     if (lim != ~0) {
         while(lim > 0 && fullString[lim-1] == ' ') --lim;
     }
     return pfc::stricmp_ascii_ex(fullString,lim, ourType, ~0) == 0;
 }

bool foobar2000_io::matchProtocol	(	const char *	fullString,
		const char *	protocolName
	)

Definition at line 1066 of file filesystem.cpp.

                                                                                     {
     const t_size len = strlen(protocolName);
     if (pfc::stricmp_ascii_ex(fullString, len, protocolName, len) != 0) return false;
     return fullString[len] == ':' && fullString[len+1] == '/' && fullString[len+2] == '/';
 }

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_aborted	,
		pfc::exception	,
		"User abort"
	)

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io	,
		pfc::exception	,
		"I/O error"
	)

Generic I/O error. Root class for I/O failure exception. See relevant default message for description of each derived exception class.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_not_found	,
		exception_io	,
		"Object not found"
	)

Object not found.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_denied	,
		exception_io	,
		"Access denied"
	)

Access denied.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_denied_readonly	,
		exception_io_denied	,
		"File is read-only"
	)

Access denied.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_data	,
		exception_io	,
		"Unsupported format or corrupted file"
	)

Unsupported format or corrupted file (unexpected data encountered).

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_data_truncation	,
		exception_io_data	,
		"Unsupported format or corrupted file"
	)

Unsupported format or corrupted file (truncation encountered).

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_unsupported_format	,
		exception_io_data	,
		"Unsupported file format"
	)

Unsupported format (a subclass of "unsupported format or corrupted file" exception).

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_object_is_remote	,
		exception_io	,
		"This operation is not supported on remote objects"
	)

Object is remote, while specific operation is supported only for local objects.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_sharing_violation	,
		exception_io	,
		"File is already in use"
	)

Sharing violation.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_device_full	,
		exception_io	,
		"Device full"
	)

Device full.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_seek_out_of_range	,
		exception_io	,
		"Seek offset out of range"
	)

Attempt to seek outside valid range.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_object_not_seekable	,
		exception_io	,
		"Object is not seekable"
	)

This operation requires a seekable object.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_no_length	,
		exception_io	,
		"Length of object is unknown"
	)

This operation requires an object with known length.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_no_handler_for_path	,
		exception_io	,
		"Invalid path"
	)

Invalid path.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_already_exists	,
		exception_io	,
		"Object already exists"
	)

Object already exists.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_no_data	,
		exception_io	,
		"The process receiving or sending data has terminated"
	)

Pipe error.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_network_not_reachable	,
		exception_io	,
		"Network not reachable"
	)

Network not reachable.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_write_protected	,
		exception_io_denied	,
		"The media is write protected"
	)

Media is write protected.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_file_corrupted	,
		exception_io	,
		"The file is corrupted"
	)

File is corrupted. This indicates filesystem call failure, not actual invalid data being read by the app.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_disk_change	,
		exception_io	,
		"Disc not available"
	)

The disc required for requested operation is not available.

foobar2000_io::PFC_DECLARE_EXCEPTION	(	exception_io_directory_not_empty	,
		exception_io	,
		"Directory not empty"
	)

The directory is not empty.

void foobar2000_io::purgeOldFiles	(	const char *	directory,
		t_filetimestamp	period,
		abort_callback &	abort
	)

Definition at line 1007 of file filesystem.cpp.

                                                                                                         {
 
     class myCallback : public directory_callback {
     public:
         myCallback(t_filetimestamp period) : m_base(filetimestamp_from_system_timer() - period) {}
         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_stats.m_timestamp < m_base) {
                 try {
                     filesystem::g_remove_timeout(p_url, 1, p_abort);
                 } catch(exception_io_not_found) {}
             }
             return true;
         }
     private:
         const t_filetimestamp m_base;
     };
 
     myCallback cb(period);
     filesystem::g_list_directory(directory, cb, abort);
 }

void foobar2000_io::substituteProtocol	(	pfc::string_base &	out,
		const char *	fullString,
		const char *	protocolName
	)

Definition at line 1071 of file filesystem.cpp.

                                                                                                                {
     const char * base = strstr(fullString, "://");
     if (base) {
         out = protocolName; out << base;
     } else {
         PFC_ASSERT(!"Should not get here");
         out = fullString;
     }
 }

PFC_NORETURN void foobar2000_io::win32_file_write_failure	(	DWORD	p_code,
		const char *	path
	)

Definition at line 765 of file filesystem.cpp.

                                                                                          {
     if (p_code == ERROR_ACCESS_DENIED) {
         const DWORD attr = uGetFileAttributes(path);
         if (attr != ~0 && (attr & FILE_ATTRIBUTE_READONLY) != 0) throw exception_io_denied_readonly();
     }
     exception_io_from_win32(p_code);
 }

Variable Documentation

const t_filesize foobar2000_io::filesize_invalid = (t_filesize)(~0)

static

Invalid/unknown file size constant. Also see: t_filesize.

Definition at line 16 of file filesystem.h.

const t_filestats foobar2000_io::filestats_invalid = {filesize_invalid,filetimestamp_invalid}

static

Invalid/unknown file stats constant. See: t_filestats.

Definition at line 75 of file filesystem.h.

const t_filetimestamp foobar2000_io::filetimestamp_1second_increment = 10000000

static

Definition at line 18 of file filesystem.h.

const t_filetimestamp foobar2000_io::filetimestamp_invalid = 0

Invalid/unknown file timestamp constant. Also see: t_filetimestamp.

Definition at line 14 of file filesystem.h.

Data Structures

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation