|T const *||get () const|
|traits::const_reference||operator* () const|
|T const *||operator-> () const|
|ReadOnlyPointer (T *ptr=0)|
|void||reset (T *ptr)|
|T *||try_write_access ()|
|bool||valid () const|
|T *||write_access ()|
|typedef ROPtrInternal< T >||Internal|
|typedef boost::call_traits< T >||traits|
|boost::intrusive_ptr< Internal >||internal|
Smart pointer that allows safe sharing of data between multiple threads
This smart pointer registers a memory area as being read-only. It can therefore be shared safely between threads without adding means of synchronization between the threads. Indeed: the value will *not* be changed between the threads.
If a thread wants to modify the value in-place (i.e. not do any copying), it can get ownership of the object referenced by the ReadOnlyPointer by calling ReadOnlyPointer::write_access. If this smart pointer if the only owner of the memory zone, then no copy will be done. Otherwise, one copy is done to satisfy the caller.
|typedef boost::call_traits<T> RTT::extras::ReadOnlyPointer< T >::traits
|traits::const_reference RTT::extras::ReadOnlyPointer< T >::operator*||(||)|| const
|T const* RTT::extras::ReadOnlyPointer< T >::operator->||(||)|| const
Modifies the value referenced by this smart pointer
After this call,
ptr is owned by the smart pointer, and the caller should not modify the value referenced by
ptr (i.e. it should be treated as read-only by the caller).
This does not change the other instances of ReadOnlyPointer that were referencing the same memory zone as
this. I.e. after the following snippet, ptr2 refers to value2 and ptr1 to value1.
T* value1 = new T; T* value2 = new T; ReadOnlyPointer<T> ptr1(value1); ReadOnlyPointer<T> ptr2(ptr1); ptr2->reset(value2);
this is the only owner of the object it refers to, this object will be deleted.
Gets write access to the pointed-to object.
this is the only owner of that object, then no copy will be done *and* the pointer will be invalidated. Otherwise, the method returns a copy of the pointed-to object.
If the copy might be a problem, one can use try_write_access to get the object only when a copy is not needed.
It is the responsibility of the caller to delete the returned value.
|boost::intrusive_ptr<Internal> RTT::extras::ReadOnlyPointer< T >::internal