efsw Namespace Reference

Namespaces
	Errors
	Platform

Functions
int	getOSXReleaseNumber ()
bool	operator== (const String &left, const String &right)
bool	operator!= (const String &left, const String &right)
bool	operator< (const String &left, const String &right)
bool	operator> (const String &left, const String &right)
bool	operator<= (const String &left, const String &right)
bool	operator>= (const String &left, const String &right)
String	operator+ (const String &left, const String &right)
int	comparator (const void *ke1, const void *ke2)
void CALLBACK	WatchCallback (DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped)
	Unpacks events and passes them to a user defined callback. More...
bool	RefreshWatch (WatcherStructWin32 *pWatch)
	Refreshes the directory monitoring. More...
void	DestroyWatch (WatcherStructWin32 *pWatch)
	Stops monitoring a directory. More...
WatcherStructWin32 *	CreateWatch (LPCWSTR szDirectory, bool recursive, DWORD NotifyFilter)
	Starts monitoring a directory. More...

Function Documentation

int efsw::comparator	(	const void *	ke1,
		const void *	ke2
	)

{
 const KEvent * kev1 = reinterpret_cast<const KEvent*>( ke1 );
 const KEvent * kev2 = reinterpret_cast<const KEvent*>( ke2 );

 if ( NULL != kev2->udata )
 {
 FileInfo * fi1 = reinterpret_cast<FileInfo*>( kev1->udata );
 FileInfo * fi2 = reinterpret_cast<FileInfo*>( kev2->udata );

 return strcmp( fi1->Filepath.c_str(), fi2->Filepath.c_str() );
 }

 return 1;
}

Here is the caller graph for this function:

WatcherStructWin32* efsw::CreateWatch	(	LPCWSTR	szDirectory,
		bool	recursive,
		DWORD	NotifyFilter
	)

Starts monitoring a directory.

{
 WatcherStructWin32 * tWatch;
 size_t ptrsize = sizeof(*tWatch);
 tWatch = static_cast<WatcherStructWin32*>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptrsize));

 WatcherWin32 * pWatch = new WatcherWin32();
 tWatch->Watch = pWatch;

 pWatch->DirHandle = CreateFileW(
 szDirectory,
 GENERIC_READ,
 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 NULL,
 OPEN_EXISTING,
 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
 NULL
 );

 if (pWatch->DirHandle != INVALID_HANDLE_VALUE)
 {
 tWatch->Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 pWatch->NotifyFilter = NotifyFilter;
 pWatch->Recursive = recursive;

 if (RefreshWatch(tWatch))
 {
 return tWatch;
 }
 else
 {
 CloseHandle(tWatch->Overlapped.hEvent);
 CloseHandle(pWatch->DirHandle);
 }
 }

 HeapFree(GetProcessHeap(), 0, tWatch);
 return NULL;
}

Here is the call graph for this function:

void efsw::DestroyWatch

(

WatcherStructWin32 *

pWatch

)

Stops monitoring a directory.

{
 if (pWatch)
 {
 WatcherWin32 * tWatch = pWatch->Watch;

 tWatch->StopNow = true;

 CancelIo(tWatch->DirHandle);

 RefreshWatch(pWatch);

 if (!HasOverlappedIoCompleted(&pWatch->Overlapped))
 {
 SleepEx(5, TRUE);
 }

 CloseHandle(pWatch->Overlapped.hEvent);
 CloseHandle(pWatch->Watch->DirHandle);
 efSAFE_DELETE_ARRAY( pWatch->Watch->DirName );
 efSAFE_DELETE( pWatch->Watch );
 HeapFree(GetProcessHeap(), 0, pWatch);
 }
}

Here is the call graph for this function:

int efsw::getOSXReleaseNumber

(

)

{
 static int osxR = -1;

 if ( -1 == osxR )
 {
 struct utsname os;

 if ( -1 != uname( &os ) ) {
 std::string release( os.release );
 
 size_t pos = release.find_first_of( '.' );
 
 if ( pos != std::string::npos )
 {
 release = release.substr( 0, pos );
 }
 
 int rel = 0;
 
 if ( String::fromString<int>( rel, release ) )
 {
 osxR = rel;
 }
 }
 }
 
 return osxR;
}

bool efsw::operator!=	(	const String &	left,
		const String &	right
	)

{
 return !(left == right);
}

String efsw::operator+	(	const String &	left,
		const String &	right
	)

{
 String string = left;
 string += right;

 return string;
}

Here is the call graph for this function:

bool efsw::operator<	(	const String &	left,
		const String &	right
	)

{
 return left.mString < right.mString;
}

bool efsw::operator<=	(	const String &	left,
		const String &	right
	)

{
 return !(right < left);
}

Here is the call graph for this function:

bool efsw::operator==	(	const String &	left,
		const String &	right
	)

{
 return left.mString == right.mString;
}

bool efsw::operator>	(	const String &	left,
		const String &	right
	)

{
 return right < left;
}

Here is the call graph for this function:

bool efsw::operator>=	(	const String &	left,
		const String &	right
	)

{
 return !(left < right);
}

bool efsw::RefreshWatch

(

WatcherStructWin32 *

pWatch

)

Refreshes the directory monitoring.

{
 return ReadDirectoryChangesW(
 pWatch->Watch->DirHandle,
 pWatch->Watch->mBuffer,
 sizeof(pWatch->Watch->mBuffer),
 pWatch->Watch->Recursive,
 pWatch->Watch->NotifyFilter,
 NULL,
 &pWatch->Overlapped,
 NULL
 ) != 0;
}

Here is the caller graph for this function:

void CALLBACK efsw::WatchCallback	(	DWORD	dwErrorCode,
		DWORD	dwNumberOfBytesTransfered,
		LPOVERLAPPED	lpOverlapped
	)

Unpacks events and passes them to a user defined callback.

{
 char szFile[MAX_PATH];
 PFILE_NOTIFY_INFORMATION pNotify;
 WatcherStructWin32 * tWatch = (WatcherStructWin32*) lpOverlapped;
 WatcherWin32 * pWatch = tWatch->Watch;
 size_t offset = 0;

 if (dwNumberOfBytesTransfered == 0)
 {
 RefreshWatch(tWatch); // If dwNumberOfBytesTransfered == 0, it means the buffer overflowed (too many changes between GetOverlappedResults calls). Those events are lost, but at least we can refresh so subsequent changes are seen again.
 return;
 }

 if (dwErrorCode == ERROR_SUCCESS)
 {
 do
 {
 bool skip = false;

 pNotify = (PFILE_NOTIFY_INFORMATION) &pWatch->mBuffer[offset];
 offset += pNotify->NextEntryOffset;

 int count = WideCharToMultiByte(CP_UTF8, 0, pNotify->FileName,
 pNotify->FileNameLength / sizeof(WCHAR),
 szFile, MAX_PATH - 1, NULL, NULL);
 szFile[count] = TEXT('\0');

 std::string nfile( szFile );

 if ( FILE_ACTION_MODIFIED == pNotify->Action )
 {
 FileInfo fifile( std::string( pWatch->DirName ) + nfile );

 if ( pWatch->LastModifiedEvent.file.ModificationTime == fifile.ModificationTime && pWatch->LastModifiedEvent.file.Size == fifile.Size && pWatch->LastModifiedEvent.fileName == nfile )
 {
 skip = true;
 }

 pWatch->LastModifiedEvent.fileName = nfile;
 pWatch->LastModifiedEvent.file = fifile;
 }

 if ( !skip )
 {
 pWatch->Watch->handleAction(pWatch, nfile, pNotify->Action);
 }
 } while (pNotify->NextEntryOffset != 0);
 }

 if (!pWatch->StopNow)
 {
 RefreshWatch(tWatch);
 }
}

Here is the call graph for this function: