Waiting for file availability

[CodeMonkey]

Is there any portable way to wait until a file becomes available (assuming it exists)? For example, I thought of this:

//assuming some other app is using "file"...
//wait until "file" is available, then delete it
while( !std::fstream("file") );
std::system("del file");

Of course, speaking of portability, the contents of system() are not. Still, then I realized how inefficient my method waswas. Something more along the lines of this was in order:

while( !std::fstream("file") )   //check every 5 seconds
{
   Sleep(5000);
}
std::system("del file");

But then Sleep() is not portable! Am I out of luck? Is this os-specific?

[CodeMonkey]

well, there's always something like

namespace my_util
{
   //with <ctime>
   inline const std::clock_t sleep(int duration,bool in_seconds = true)
   { 
      std::clock_t start = std::clock(NULL);
      while( std::clock(NULL) < start+duration*(in_seconds ? std::CLOCKS_PER_SEC : 1) );
      return std::CLOCKS_PER_SEC;
   }
}

But what about deleting a file?

[Desolation]

It seems remove() is the solution.

[vart]

well, there's always something like

namespace my_util
{
   //with <ctime>
   inline const std::clock_t sleep(int duration,bool in_seconds = true)
   { 
      std::clock_t start = std::clock(NULL);
      while( std::clock(NULL) < start+duration*(in_seconds ? std::CLOCKS_PER_SEC : 1) );
      return std::CLOCKS_PER_SEC;
   }
}

Have you measured the CPU usage in your solution?

[CodeMonkey]

It's, well..... absolutely gigantic. BTW, thanks Desolation.

[vart]

I'd put something like

#ifdef WIN32
   Sleep(duration);
#elif _UNIX
   sleep(duration/1000);
#else
   ...
#endif

in my code to support different OSes when to go with the solution that eats my CPU time even if it is universal

[Desolation]

Small variation on vart's code, just in case you want to use the timer more than once.

#ifdef WIN32
    #define SLEEP_MS(a) Sleep(a)
#elif _UNIX
    #define SLEEP_MS(a) sleep( (a) / 1000 )
#elif
    ...
#endif

[vart]

Small variation on vart's code, just in case you want to use the timer more than once.

#ifdef WIN32
    #define SLEEP_MS(a) Sleep(a)
#elif _UNIX
    #define SLEEP_MS(a) sleep( (a) / 1000 )
#elif
    ...
#endif

I prefer to create function named SLEEP_MS than macro.
Didn't mean that my code should go in the place where we need to call Sleep,
Instead it should be wrapped in some utility function and place in the file containing all OS adapters.

[CodeMonkey]

Yes, that's the solution I've been finding online. Thank you.

[vart]

Here http://cboard.cprogramming.com/showp...66&postcount=9
CornedBee suggested even better solution that uses the same idea

[CornedBee]

However, the idea of this thread is not portable in the first place. Unless the application that currently has the file open locked it explicitly, you can simply delete it in Linux (and probably most Unices). The immediate and strong locking that Windows does isn't the situation everywhere. In other words, deleting the file would succeed immediately, leaving the other application with a phantom file. Strictly speaking, you're only removing the symbolic name of the file from the directory - hence the term "unlink". The actual file, identified by its inode number, is still there, and stays there as long as anything holds a reference. And the open file descriptor of that other application is a reference. The file will be deleted from disk the moment the other application closes its file descriptor.
The waiting is thus only necessary in Windows in the first place, which suggests implementing a platform-specific proper waiting method there. I have to admit, though, that I'm not sure what the right method is. LockFile(Ex) require an open handle, and I'm not sure if a statistics handle (the only that can be opened on an already locked file) is enough.