Fmode(3pm) User Contributed Perl Documentation Fmode(3pm)NAME
FileHandle::Fmode - determine whether a filehandle is opened for reading, writing, or both.
SYNOPSIS
use FileHandle::Fmode qw(:all);
.
.
#$fh and FH are open filehandles
print is_R($fh), "
";
print is_W(*FH), "
";
FUNCTIONS
$bool = is_FH($fh);
$bool = is_FH(*FH);
This is just a (more intuitively named) alias for is_arg_ok().
Returns 1 if its argument is an open filehandle.
Returns 0 if its argument is something other than an open filehandle.
$bool = is_arg_ok($fh);
$bool = is_arg_ok(*FH);
Returns 1 if its argument is an open filehandle.
Returns 0 if its argument is something other than an open filehandle.
Arguments to the following functions must be open filehandles. If
any of those functions receive an argument that is not an open
filehandle then the function dies with an appropriate error message.
To ensure that your script won't suffer such a death, you could first
check by passing the argument to is_FH(). Or you could wrap the
function call in an eval{} block.
Note that it may be possible that a filehandle opened for writing may
become unwritable - if (eg) the disk becomes full. I don't know how
the below functions would be affected by such an event. I suspect
that they would be unaware of the change ... but I haven't actually
checked.
$bool = is_R($fh);
$bool = is_R(*FH);
Returns true if the filehandle is readable.
Else returns false.
$bool = is_W($fh);
$bool = is_W(*FH);
Returns true if the filehandle is writable.
Else returns false
$bool = is_RO($fh);
$bool = is_RO(*FH);
Returns true if the filehandle is readable but not writable.
Else returns false
$bool = is_WO($fh);
$bool = is_WO(*FH);
Returns true if the filehandle is writable but not readable.
Else returns false
$bool = is_RW($fh);
$bool = is_RW(*FH);
Returns true if the filehandle is both readable and writable.
Else returns false
$bool = is_A($fh);
$bool = is_A(*FH);
Returns true if the filehandle was opened for appending.
Else returns false.
Not currently implemented on Win32 with pre-5.6.1 versions of perl (and
dies with appropriate error message if called on such a platform).
CREDITS
Inspired (hmmm ... is that the right word ?) by an idea from BrowserUK
posted on PerlMonks in response to a question from dragonchild. Win32
code (including XS code) provided by BrowserUK. Zaxo presented the idea
of using fcntl() in an earlier PerlMonks thread.
Thanks to dragonchild and BrowserUK for steering this module in
the right direction.
Thanks to attn.steven.kuo for directing me to the perliol routines
that enable us to query filehandles attached to memory objects.
And thanks to Jost Krieger for helping to sort out the test failures that
were occurring on Solaris (and some other operating systems too).
TODO
I don't know that anyone still runs pre-5.6.1 perl on Win32. However, if
someone likes to tell me how is_A() could be made to work on pre-5.6.1
Win32 perl, I would be quite happy to implement it.
LICENSE
This program is free software; you may redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 2006-2008, Sisyphus
AUTHOR
Sisyphus <sisyphus at cpan dot org>
perl v5.14.2 2008-09-26 Fmode(3pm)
Check Out this Related Man Page
fileevent(3pm) User Contributed Perl Documentation fileevent(3pm)NAME
Tk::fileevent - Execute a callback when a filehandle becomes readable or writable
SYNOPSIS
$widget->fileevent(fileHandle,readable?,callback?)
$widget->fileevent(fileHandle,writable?,callback?)
DESCRIPTION
This command is used to create file event handlers. A file event handler is a binding between a filehandle and a callback, such that the
callback is evaluated whenever the filehandle becomes readable or writable. File event handlers are most commonly used to allow data to be
received from another process on an event-driven basis, so that the receiver can continue to interact with the user while waiting for the
data to arrive. If an application invokes "<>", "sysread" or "read" on a blocking filehandle when there is no input data available, the
process will block; until the input data arrives, it will not be able to service other events, so it will appear to the user to ``freeze
up''. With fileevent, the process can tell when data is present and only invoke gets or read when they won't block.
The fileHandle argument to fileevent refers to an open filehandle, such as the return value from a previous open or socket command. If the
callback argument is specified, then fileevent creates a new event handler: callback will be evaluated whenever the filehandle becomes
readable or writable (depending on the argument to fileevent). In this case fileevent returns an empty string. The readable and writable
event handlers for a file are independent, and may be created and deleted separately. However, there may be at most one readable and one
writable handler for a file at a given time in a given interpreter. If fileevent is called when the specified handler already exists in
the invoking interpreter, the new callback replaces the old one.
If the callback argument is not specified, fileevent returns the current callback for fileHandle, or an empty string if there is none. If
the callback argument is specified as an empty string then the event handler is deleted, so that no callback will be invoked. A file event
handler is also deleted automatically whenever its filehandle is closed or its interpreter is deleted.
A filehandle is considered to be readable if there is unread data available on the underlying device. A filehandle is also considered to
be readable if an end of file or error condition is present on the underlying file or device. It is important for callback to check for
these conditions and handle them appropriately; for example, if there is no special check for end of file, an infinite loop may occur
where callback reads no data, returns, and is immediately invoked again.
A filehandle is considered to be writable if at least one byte of data can be written to the underlying file or device without blocking, or
if an error condition is present on the underlying file or device.
Event-driven I/O works best for filehandles that have been placed into nonblocking mode. In blocking mode, a "print" command may block if
you give it more data than the underlying file or device can accept, and a "<>", "sysread" or "read" command will block if you attempt to
read more data than is ready; no events will be processed while the commands block. In nonblocking mode "print", "<>", "sysread" and
"read" never block. See the documentation for the individual commands for information on how they handle blocking and nonblocking
filehandles.
The callback for a file event is executed in the context of $widget with which fileevent was invoked. If an error occurs while executing
the callback then the Tk::Error mechanism is used to report the error. In addition, the file event handler is deleted if it ever returns
an error; this is done in order to prevent infinite loops due to buggy handlers.
BUGS
On windows platforms fileevent is limited in the types of filehandles that behave correctly. Making filefhandles non-blocking is only
implemented on a subset of UNIX platforms (see Tk::IO).
CREDITS
fileevent is based on the addinput command created by Mark Diekhans.
SEE ALSO
Tk::IO Tk::callbacks
KEYWORDS
asynchronous I/O, blocking, filehandle, event handler, nonblocking, readable, callback, writable.
perl v5.14.2 2010-05-29 fileevent(3pm)