#include <safecoll.h>
Public Member Functions | |
Construction | |
| PSafePtr (T *obj=NULL, PSafetyMode mode=PSafeReference) | |
| PSafePtr (const PSafeCollection &safeCollection, PSafetyMode mode=PSafeReadWrite, PINDEX idx=0) | |
| PSafePtr (const PSafeCollection &safeCollection, PSafetyMode mode, PSafeObject *obj) | |
| PSafePtr (const PSafePtr &ptr) | |
| PSafePtr & | operator= (const PSafePtr &ptr) |
| PSafePtr & | operator= (const PSafeCollection &safeCollection) |
| PSafePtr & | operator= (T *obj) |
| PSafePtr & | operator= (PINDEX idx) |
Operations | |
| operator T * () const | |
| T & | operator * () const |
| T * | operator-> () const |
| T * | operator++ (int) |
| T * | operator++ () |
| T * | operator-- (int) |
| T * | operator-- () |
This is part of a set of classes to solve the general problem of a collection (eg a PList or PDictionary) of objects that needs to be a made thread safe. Any thread can add, read, write or remove an object with both the object and the database of objects itself kept thread safe.
There are two modes of safe pointer, one that is enumerating a collection and one that is independent of the collection that the safe object is in. There are some subtle semantics that must be observed in each of these two modes especially when switching from one to the other.
NOTE: the PSafePtr will allow safe and mutexed access to objects but may not thread safe itself! This depends on the base calass being used. If the more efficiant PSafePtrBase class is used you should not share PSafePtr instances across threads.
See the PSafeObject class for more details. Especially in regard to enumeration of collections.
| PSafePtr< T, BaseClass >::PSafePtr | ( | T * | obj = NULL, |
|
| PSafetyMode | mode = PSafeReference | |||
| ) | [inline] |
Create a new pointer to a PSafeObject. An optional locking mode may be provided to lock the object for reading or writing and automatically unlock it on destruction.
Note that this version is not associated with a collection so the ++ and -- operators will not work.
| obj | Physical object to point to. |
| mode | Locking mode for the object |
| PSafePtr< T, BaseClass >::PSafePtr | ( | const PSafeCollection & | safeCollection, | |
| PSafetyMode | mode = PSafeReadWrite, |
|||
| PINDEX | idx = 0 | |||
| ) | [inline] |
Create a new pointer to a PSafeObject. An optional locking mode may be provided to lock the object for reading or writing and automatically unlock it on destruction.
The idx'th entry of the collection is pointed to by this object. If the idx is beyond the size of the collection, the pointer is NULL.
| safeCollection | Collection pointer will enumerate |
| mode | Locking mode for the object |
| idx | Index into collection to point to |
| PSafePtr< T, BaseClass >::PSafePtr | ( | const PSafeCollection & | safeCollection, | |
| PSafetyMode | mode, | |||
| PSafeObject * | obj | |||
| ) | [inline] |
Create a new pointer to a PSafeObject. An optional locking mode may be provided to lock the object for reading or writing and automatically unlock it on destruction.
The obj parameter is only set if it contained in the collection, otherwise the pointer is NULL.
| safeCollection | Collection pointer will enumerate |
| mode | Locking mode for the object |
| obj | Inital object in collection to point to |
| PSafePtr< T, BaseClass >::PSafePtr | ( | const PSafePtr< T, BaseClass > & | ptr | ) | [inline] |
Copy the pointer to the PSafeObject. This will create a copy of the pointer with the same locking mode and lock on the PSafeObject. It will also increment the reference count on the PSafeObject as well.
| ptr | Pointer to copy |
| T& PSafePtr< T, BaseClass >::operator * | ( | ) | const [inline] |
Return the physical pointer to the object.
| PSafePtr< T, BaseClass >::operator T * | ( | ) | const [inline] |
Return the physical pointer to the object.
| T* PSafePtr< T, BaseClass >::operator++ | ( | ) | [inline] |
Pre-increment the pointer. This requires that the pointer has been created with a PSafeCollection object so that it can enumerate the collection.
| T* PSafePtr< T, BaseClass >::operator++ | ( | int | ) | [inline] |
Post-increment the pointer. This requires that the pointer has been created with a PSafeCollection object so that it can enumerate the collection.
| T* PSafePtr< T, BaseClass >::operator-- | ( | ) | [inline] |
Pre-decrement the pointer. This requires that the pointer has been created with a PSafeCollection object so that it can enumerate the collection.
| T* PSafePtr< T, BaseClass >::operator-- | ( | int | ) | [inline] |
Post-decrement the pointer. This requires that the pointer has been created with a PSafeCollection object so that it can enumerate the collection.
| T* PSafePtr< T, BaseClass >::operator-> | ( | ) | const [inline] |
Allow access to the physical object the pointer is pointing to.
| PSafePtr& PSafePtr< T, BaseClass >::operator= | ( | PINDEX | idx | ) | [inline] |
Set the new pointer to a collection index. This will set the pointer to the new object to the index entry in the colelction that the pointer was created with. The old object pointed to will be unlocked and dereferenced and the new object referenced and set to the same locking mode as the previous pointer value.
If the idx'th object is not in the collection, then the safe pointer is set to NULL.
| PSafePtr& PSafePtr< T, BaseClass >::operator= | ( | T * | obj | ) | [inline] |
Set the new pointer to a PSafeObject. This will set the pointer to the new object. The old object pointed to will be unlocked and dereferenced and the new object referenced.
If the safe pointer has an associated collection and the new object is in that collection, then the object is set to the same locking mode as the previous pointer value. This, in effect, jumps the enumeration of a collection to the specifed object.
If the safe pointer has no associated collection or the object is not in the associated collection, then the object is always only referenced and there is no read only or read/write lock done. In addition any associated collection is removed so this becomes a non enumerating safe pointer.
| PSafePtr& PSafePtr< T, BaseClass >::operator= | ( | const PSafeCollection & | safeCollection | ) | [inline] |
Start an enumerated PSafeObject. This will create a read/write locked reference to teh first element in the collection.
| PSafePtr& PSafePtr< T, BaseClass >::operator= | ( | const PSafePtr< T, BaseClass > & | ptr | ) | [inline] |
Copy the pointer to the PSafeObject. This will create a copy of the pointer with the same locking mode and lock on the PSafeObject. It will also increment the reference count on the PSafeObject as well.
1.4.7