#include <File_Lock.h>
Collaboration diagram for ACE_File_Lock:
Public Member Functions | |
ACE_File_Lock (ACE_HANDLE handle=ACE_INVALID_HANDLE, int unlink_in_destructor=1) | |
ACE_File_Lock (const ACE_TCHAR *filename, int flags, mode_t mode=0, int unlink_in_destructor=1) | |
int | open (const ACE_TCHAR *filename, int flags, mode_t mode=0) |
~ACE_File_Lock (void) | |
Remove a File lock by releasing it and closing down the . | |
int | remove (int unlink_file=1) |
int | acquire (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | tryacquire (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | release (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
Unlock a readers/writer lock. | |
int | acquire_write (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | tryacquire_write (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | tryacquire_write_upgrade (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | acquire_read (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
int | tryacquire_read (short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=1) |
ACE_HANDLE | get_handle (void) const |
Get underlying ACE_HANDLE for the file. | |
void | set_handle (ACE_HANDLE) |
void | dump (void) const |
Dump state of the object. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Attributes | |
ACE_OS::ace_flock_t | lock_ |
Locking structure for OS record locks. | |
int | removed_ |
int | unlink_in_destructor_ |
Private Member Functions | |
void | operator= (const ACE_File_Lock &) |
ACE_File_Lock (const ACE_File_Lock &) |
Allows us to "adapt" the UNIX file locking mechanisms to work with all of our Guard stuff...
Definition at line 35 of file File_Lock.h.
|
Set the of the File_Lock to . Note that this constructor assumes ownership of the and will close it down in . If you want the to stay open when is called make sure to call on the . If you don't want the file unlinked in the destructor pass a zero value for . Definition at line 28 of file File_Lock.cpp. References ACE_ERROR, ACE_TEXT, ACE_OS::flock_init(), LM_ERROR, and set_handle().
00030 : removed_ (0), 00031 unlink_in_destructor_ (unlink_in_destructor) 00032 { 00033 // ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); 00034 if (ACE_OS::flock_init (&this->lock_) == -1) 00035 ACE_ERROR ((LM_ERROR, 00036 ACE_TEXT ("%p\n"), 00037 ACE_TEXT ("ACE_File_Lock::ACE_File_Lock"))); 00038 this->set_handle (h); 00039 } |
|
Open the with and and set the result to . If you don't want the file unlinked in the destructor pass a zero value for . Definition at line 41 of file File_Lock.cpp. References ACE_ERROR, ACE_TCHAR, ACE_TEXT, LM_ERROR, mode_t, and open().
00045 : unlink_in_destructor_ (unlink_in_destructor) 00046 { 00047 // ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); 00048 00049 if (this->open (name, flags, perms) == -1) 00050 ACE_ERROR ((LM_ERROR, 00051 ACE_TEXT ("%p %s\n"), 00052 ACE_TEXT ("ACE_File_Lock::ACE_File_Lock"), 00053 name)); 00054 } |
|
Remove a File lock by releasing it and closing down the .
Definition at line 66 of file File_Lock.cpp. References remove().
00067 { 00068 // ACE_TRACE ("ACE_File_Lock::~ACE_File_Lock"); 00069 this->remove (this->unlink_in_destructor_); 00070 } |
|
|
|
Note, for interface uniformity with other synchronization wrappers we include the method. This is implemented as a write-lock to be on the safe-side... Definition at line 52 of file File_Lock.inl. References ACE_OFF_T, and acquire_write(). Referenced by ACE_RW_Process_Mutex::acquire().
00053 { 00054 // ACE_TRACE ("ACE_File_Lock::acquire"); 00055 return this->acquire_write (whence, start, len); 00056 } |
|
Acquire a read lock, but block if a writer hold the lock. Returns -1 on failure. If we "failed" because someone else already had the lock, Definition at line 8 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_rdlock(). Referenced by ACE_RW_Process_Mutex::acquire_read().
00009 { 00010 // ACE_TRACE ("ACE_File_Lock::acquire_read"); 00011 return ACE_OS::flock_rdlock (&this->lock_, whence, start, len); 00012 } |
|
Acquire a write lock, but block if any readers or a writer hold the lock. Definition at line 45 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_wrlock(). Referenced by acquire(), and ACE_RW_Process_Mutex::acquire_write().
00046 { 00047 // ACE_TRACE ("ACE_File_Lock::acquire_write"); 00048 return ACE_OS::flock_wrlock (&this->lock_, whence, start, len); 00049 } |
|
Dump state of the object.
Definition at line 17 of file File_Lock.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_OS::ace_flock_t::dump(), and LM_DEBUG. Referenced by ACE_RW_Process_Mutex::dump().
|
|
Get underlying ACE_HANDLE for the file.
Definition at line 82 of file File_Lock.inl. References ACE_OS::ace_flock_t::handle_.
|
|
Open the with and and set the result to . Definition at line 57 of file File_Lock.cpp. References ACE_TCHAR, ACE_OS::flock_init(), and mode_t. Referenced by ACE_File_Lock().
00060 { 00061 // ACE_TRACE ("ACE_File_Lock::open"); 00062 this->removed_ = 0; 00063 return ACE_OS::flock_init (&this->lock_, flags, name, perms); 00064 } |
|
|
|
Unlock a readers/writer lock.
Definition at line 59 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_unlock(). Referenced by ACE_RW_Process_Mutex::release().
00060 { 00061 // ACE_TRACE ("ACE_File_Lock::release"); 00062 return ACE_OS::flock_unlock (&this->lock_, whence, start, len); 00063 } |
|
Remove a File lock by releasing it and closing down the . If is non-0 then we unlink the file. Definition at line 66 of file File_Lock.inl. References ACE_OS::flock_destroy(). Referenced by ACE_RW_Process_Mutex::remove(), and ~ACE_File_Lock().
00067 { 00068 // ACE_TRACE ("ACE_File_Lock::remove"); 00069 00070 int result = 0; 00071 00072 if (this->removed_ == 0) 00073 { 00074 this->removed_ = 1; 00075 result = ACE_OS::flock_destroy (&this->lock_, 00076 unlink_file); 00077 } 00078 return result; 00079 } |
|
Set underlying ACE_HANDLE. Note that this method assumes ownership of the and will close it down in . If you want the to stay open when is called make sure to call on the before closing it. You are responsible for the closing the existing before overwriting it. Definition at line 89 of file File_Lock.inl. References ACE_OS::ace_flock_t::handle_. Referenced by ACE_File_Lock().
|
|
Note, for interface uniformity with other synchronization wrappers we include the method. This is implemented as a write-lock to be on the safe-side... Returns -1 on failure. If we "failed" because someone else already had the lock, Definition at line 38 of file File_Lock.inl. References ACE_OFF_T, and tryacquire_write(). Referenced by ACE_RW_Process_Mutex::tryacquire().
00039 { 00040 // ACE_TRACE ("ACE_File_Lock::tryacquire"); 00041 return this->tryacquire_write (whence, start, len); 00042 } |
|
Conditionally acquire a read lock (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, Definition at line 15 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_tryrdlock(). Referenced by ACE_RW_Process_Mutex::tryacquire_read().
00016 { 00017 // ACE_TRACE ("ACE_File_Lock::tryacquire_read"); 00018 return ACE_OS::flock_tryrdlock (&this->lock_, whence, start, len); 00019 } |
|
Conditionally acquire a write lock (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, Definition at line 22 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_trywrlock(). Referenced by tryacquire(), and ACE_RW_Process_Mutex::tryacquire_write().
00023 { 00024 // ACE_TRACE ("ACE_File_Lock::tryacquire_write"); 00025 return ACE_OS::flock_trywrlock (&this->lock_, whence, start, len); 00026 } |
|
Conditionally upgrade to a write lock (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, Definition at line 29 of file File_Lock.inl. References ACE_OFF_T, and ACE_OS::flock_trywrlock(). Referenced by ACE_RW_Process_Mutex::tryacquire_write_upgrade().
00032 { 00033 // ACE_TRACE ("ACE_File_Lock::tryacquire_write_upgrade"); 00034 return ACE_OS::flock_trywrlock (&this->lock_, whence, start, len); 00035 } |
|
Declare the dynamic allocation hooks.
Definition at line 140 of file File_Lock.h. |
|
Locking structure for OS record locks.
Definition at line 144 of file File_Lock.h. |
|
Keeps track of whether has been called yet to avoid multiple calls, e.g., explicitly and implicitly in the destructor. This flag isn't protected by a lock, so make sure that you don't have multiple threads simultaneously calling on the same object, which is a bad idea anyway... Definition at line 151 of file File_Lock.h. |
|
Keeps track of whether to unlink the underlying file in the destructor. Definition at line 155 of file File_Lock.h. |