#include <Bound_Ptr.h>
Collaboration diagram for ACE_Weak_Bound_Ptr< X, ACE_LOCK >:
Public Member Functions | |
ACE_Weak_Bound_Ptr (X *p=0) | |
ACE_Weak_Bound_Ptr (const ACE_Weak_Bound_Ptr< X, ACE_LOCK > &r) | |
Copy constructor binds this and r to the same object. | |
ACE_Weak_Bound_Ptr (const ACE_Strong_Bound_Ptr< X, ACE_LOCK > &r) | |
Constructor binds this and r to the same object. | |
~ACE_Weak_Bound_Ptr (void) | |
Destructor. | |
void | operator= (const ACE_Weak_Bound_Ptr< X, ACE_LOCK > &r) |
Assignment operator that binds this and r to the same object. | |
void | operator= (const ACE_Strong_Bound_Ptr< X, ACE_LOCK > &r) |
Assignment operator that binds this and r to the same object. | |
bool | operator== (const ACE_Weak_Bound_Ptr< X, ACE_LOCK > &r) const |
bool | operator== (const ACE_Strong_Bound_Ptr< X, ACE_LOCK > &r) const |
bool | operator== (X *p) const |
bool | operator!= (const ACE_Weak_Bound_Ptr< X, ACE_LOCK > &r) const |
Inequality operator, which is the opposite of equality. | |
bool | operator!= (const ACE_Strong_Bound_Ptr< X, ACE_LOCK > &r) const |
Inequality operator, which is the opposite of equality. | |
bool | operator!= (X *p) const |
Inequality operator, which is the opposite of equality. | |
ACE_Strong_Bound_Ptr< X, ACE_LOCK > | operator-> (void) const |
Redirection operator. | |
ACE_Strong_Bound_Ptr< X, ACE_LOCK > | strong (void) const |
X * | unsafe_get (void) const |
void | reset (X *p=0) |
long | add_ref (void) |
Increment the reference count on the underlying object. | |
long | remove_ref (void) |
int | null (void) const |
Allows us to check for NULL on all ACE_Weak_Bound_Ptr objects. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Private Types | |
typedef X | X_t |
typedef ACE_Bound_Ptr_Counter< ACE_LOCK > | COUNTER |
The ACE_Bound_Ptr_Counter type. | |
Private Attributes | |
COUNTER * | counter_ |
The reference counter. | |
X * | ptr_ |
The underlying object. | |
Friends | |
class | ACE_Strong_Bound_Ptr< X, ACE_LOCK > |
Unlike ACE_Strong_Bound_Ptr, assigning or copying instances of an ACE_Weak_Bound_Ptr will not automatically increment the reference count of the underlying object. What ACE_Weak_Bound_Ptr does is preserve the knowledge that the object is in fact reference counted, and thus provides an alternative to raw pointers where non-ownership associations must be maintained. When the last instance of an ACE_Strong_Bound_Ptr that references a particular object is destroyed or overwritten, the corresponding ACE_Weak_Bound_Ptr instances are set to NULL.
Definition at line 266 of file Bound_Ptr.h.
typedef ACE_Bound_Ptr_Counter<ACE_LOCK> ACE_Weak_Bound_Ptr< X, ACE_LOCK >::COUNTER [private] |
typedef X ACE_Weak_Bound_Ptr< X, ACE_LOCK >::X_t [private] |
Definition at line 368 of file Bound_Ptr.h.
ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ACE_Weak_Bound_Ptr | ( | X * | p = 0 |
) | [inline, explicit] |
Constructor that initializes an ACE_Weak_Bound_Ptr to point to the object <p> immediately.
Definition at line 320 of file Bound_Ptr.inl.
00321 : counter_ (COUNTER::create_weak ()), 00322 ptr_ (p) 00323 { 00324 }
ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ACE_Weak_Bound_Ptr | ( | const ACE_Weak_Bound_Ptr< X, ACE_LOCK > & | r | ) | [inline] |
Copy constructor binds this
and r to the same object.
Definition at line 327 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::attach_weak().
00328 : counter_ (r.counter_), 00329 ptr_ (r.ptr_) 00330 { 00331 COUNTER::attach_weak (this->counter_); 00332 }
ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ACE_Weak_Bound_Ptr | ( | const ACE_Strong_Bound_Ptr< X, ACE_LOCK > & | r | ) | [inline] |
Constructor binds this
and r to the same object.
Definition at line 335 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::attach_weak().
00336 : counter_ (r.counter_), 00337 ptr_ (r.ptr_) 00338 { 00339 COUNTER::attach_weak (this->counter_); 00340 }
ACE_Weak_Bound_Ptr< X, ACE_LOCK >::~ACE_Weak_Bound_Ptr | ( | void | ) | [inline] |
Destructor.
Definition at line 343 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::detach_weak().
00344 { 00345 COUNTER::detach_weak (this->counter_); 00346 }
long ACE_Weak_Bound_Ptr< X, ACE_LOCK >::add_ref | ( | void | ) | [inline] |
Increment the reference count on the underlying object.
Returns the new reference count on the object. This function may be used to integrate the bound pointers into an external reference counting mechanism such as those used by COM or CORBA servants.
Definition at line 477 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::attach_strong(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_.
00478 { 00479 return COUNTER::attach_strong (counter_); 00480 }
int ACE_Weak_Bound_Ptr< X, ACE_LOCK >::null | ( | void | ) | const [inline] |
Allows us to check for NULL on all ACE_Weak_Bound_Ptr objects.
Definition at line 457 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00458 { 00459 // A weak pointer must behave as though it is automatically set to null 00460 // if the underlying object has been deleted. 00461 if (COUNTER::object_was_deleted (this->counter_)) 00462 return 1; 00463 00464 return this->ptr_ == 0; 00465 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator!= | ( | X * | p | ) | const [inline] |
Inequality operator, which is the opposite of equality.
Definition at line 426 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00427 { 00428 // A weak pointer must behave as though it is automatically set to null 00429 // if the underlying object has been deleted. 00430 if (COUNTER::object_was_deleted (this->counter_)) 00431 return p != 0; 00432 00433 return this->ptr_ != p; 00434 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator!= | ( | const ACE_Strong_Bound_Ptr< X, ACE_LOCK > & | r | ) | const [inline] |
Inequality operator, which is the opposite of equality.
Definition at line 415 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_, and ACE_Strong_Bound_Ptr< X, ACE_LOCK >::ptr_.
00416 { 00417 // A weak pointer must behave as though it is automatically set to null 00418 // if the underlying object has been deleted. 00419 if (COUNTER::object_was_deleted (this->counter_)) 00420 return r.ptr_ != 0; 00421 00422 return this->ptr_ != r.ptr_; 00423 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator!= | ( | const ACE_Weak_Bound_Ptr< X, ACE_LOCK > & | r | ) | const [inline] |
Inequality operator, which is the opposite of equality.
Definition at line 404 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00405 { 00406 // A weak pointer must behave as though it is automatically set to null 00407 // if the underlying object has been deleted. 00408 if (COUNTER::object_was_deleted (this->counter_)) 00409 return r.ptr_ != 0; 00410 00411 return this->ptr_ != r.ptr_; 00412 }
ACE_Strong_Bound_Ptr< X, ACE_LOCK > ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator-> | ( | void | ) | const [inline] |
Redirection operator.
It returns a temporary strong pointer and makes use of the chaining properties of operator-> to ensure that the underlying object does not disappear while you are using it. If you are certain of the lifetimes of the object, and do not want to incur the locking overhead, then use the unsafe_get method instead.
Definition at line 437 of file Bound_Ptr.inl.
00438 { 00439 return ACE_Strong_Bound_Ptr<X, ACE_LOCK> (*this); 00440 }
void ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator= | ( | const ACE_Strong_Bound_Ptr< X, ACE_LOCK > & | r | ) | [inline] |
Assignment operator that binds this
and r to the same object.
Definition at line 360 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::attach_weak(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::counter_, ACE_Bound_Ptr_Counter< ACE_LOCK >::detach_weak(), ACE_Strong_Bound_Ptr< X, ACE_LOCK >::ptr_, and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00361 { 00362 // This will work if &rhs == this, by first increasing the ref count 00363 COUNTER *new_counter = rhs.counter_; 00364 COUNTER::attach_weak (new_counter); 00365 COUNTER::detach_weak (this->counter_); 00366 this->counter_ = new_counter; 00367 this->ptr_ = rhs.ptr_; 00368 }
void ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator= | ( | const ACE_Weak_Bound_Ptr< X, ACE_LOCK > & | r | ) | [inline] |
Assignment operator that binds this
and r to the same object.
Definition at line 349 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::attach_weak(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_, ACE_Bound_Ptr_Counter< ACE_LOCK >::detach_weak(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00350 { 00351 // This will work if &rhs == this, by first increasing the ref count 00352 COUNTER *new_counter = rhs.counter_; 00353 COUNTER::attach_weak (new_counter); 00354 COUNTER::detach_weak (this->counter_); 00355 this->counter_ = new_counter; 00356 this->ptr_ = rhs.ptr_; 00357 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator== | ( | X * | p | ) | const [inline] |
Equality operator that returns true
if the ACE_Weak_Bound_Ptr and the raw pointer point to the same underlying object.
Definition at line 393 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00394 { 00395 // A weak pointer must behave as though it is automatically set to null 00396 // if the underlying object has been deleted. 00397 if (COUNTER::object_was_deleted (this->counter_)) 00398 return p == 0; 00399 00400 return this->ptr_ == p; 00401 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator== | ( | const ACE_Strong_Bound_Ptr< X, ACE_LOCK > & | r | ) | const [inline] |
true
if both objects have just been instantiated and not used yet. Definition at line 382 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_, and ACE_Strong_Bound_Ptr< X, ACE_LOCK >::ptr_.
00383 { 00384 // A weak pointer must behave as though it is automatically set to null 00385 // if the underlying object has been deleted. 00386 if (COUNTER::object_was_deleted (this->counter_)) 00387 return r.ptr_ == 0; 00388 00389 return this->ptr_ == r.ptr_; 00390 }
bool ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator== | ( | const ACE_Weak_Bound_Ptr< X, ACE_LOCK > & | r | ) | const [inline] |
true
if both objects have just been instantiated and not used yet. Definition at line 371 of file Bound_Ptr.inl.
References ACE_Bound_Ptr_Counter< ACE_LOCK >::object_was_deleted(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00372 { 00373 // A weak pointer must behave as though it is automatically set to null 00374 // if the underlying object has been deleted. 00375 if (COUNTER::object_was_deleted (this->counter_)) 00376 return r.ptr_ == 0; 00377 00378 return this->ptr_ == r.ptr_; 00379 }
long ACE_Weak_Bound_Ptr< X, ACE_LOCK >::remove_ref | ( | void | ) | [inline] |
Returns the new reference count on the object. This function may be used to integrate the bound pointers into an external reference counting mechanism such as those used by COM or CORBA servants.
Definition at line 483 of file Bound_Ptr.inl.
References ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_, ACE_Bound_Ptr_Counter< ACE_LOCK >::detach_strong(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00484 { 00485 long new_obj_ref_count = COUNTER::detach_strong (counter_); 00486 if (new_obj_ref_count == 0) 00487 { 00488 delete this->ptr_; 00489 this->ptr_ = 0; 00490 } 00491 return new_obj_ref_count; 00492 }
void ACE_Weak_Bound_Ptr< X, ACE_LOCK >::reset | ( | X * | p = 0 |
) | [inline] |
Resets the ACE_Weak_Bound_Ptr to refer to a different underlying object.
Definition at line 468 of file Bound_Ptr.inl.
References ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_, ACE_Bound_Ptr_Counter< ACE_LOCK >::create_weak(), ACE_Bound_Ptr_Counter< ACE_LOCK >::detach_weak(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00469 { 00470 COUNTER *old_counter = this->counter_; 00471 this->counter_ = COUNTER::create_weak (); 00472 this->ptr_ = p; 00473 COUNTER::detach_weak (old_counter); 00474 }
ACE_Strong_Bound_Ptr< X, ACE_LOCK > ACE_Weak_Bound_Ptr< X, ACE_LOCK >::strong | ( | void | ) | const [inline] |
Obtain a strong pointer corresponding to this weak pointer. This function is useful to create a temporary strong pointer for conversion to a reference.
Definition at line 443 of file Bound_Ptr.inl.
00444 { 00445 return ACE_Strong_Bound_Ptr<X, ACE_LOCK> (*this); 00446 }
X * ACE_Weak_Bound_Ptr< X, ACE_LOCK >::unsafe_get | ( | void | ) | const [inline] |
Get the pointer value. Warning: this does not affect the reference count of the underlying object, so it may disappear on you while you are using it if you are not careful.
Definition at line 449 of file Bound_Ptr.inl.
References ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_.
00450 { 00451 // We do not check if the object has been deleted, since this operation 00452 // is defined to be unsafe! 00453 return this->ptr_; 00454 }
friend class ACE_Strong_Bound_Ptr< X, ACE_LOCK > [friend] |
Definition at line 370 of file Bound_Ptr.h.
ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ACE_ALLOC_HOOK_DECLARE |
COUNTER* ACE_Weak_Bound_Ptr< X, ACE_LOCK >::counter_ [private] |
The reference counter.
Definition at line 376 of file Bound_Ptr.h.
Referenced by ACE_Weak_Bound_Ptr< X, ACE_LOCK >::add_ref(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator=(), ACE_Strong_Bound_Ptr< X, ACE_LOCK >::operator=(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::remove_ref(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::reset().
X* ACE_Weak_Bound_Ptr< X, ACE_LOCK >::ptr_ [private] |
The underlying object.
Definition at line 379 of file Bound_Ptr.h.
Referenced by ACE_Weak_Bound_Ptr< X, ACE_LOCK >::null(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator!=(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator=(), ACE_Strong_Bound_Ptr< X, ACE_LOCK >::operator=(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::operator==(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::remove_ref(), ACE_Weak_Bound_Ptr< X, ACE_LOCK >::reset(), and ACE_Weak_Bound_Ptr< X, ACE_LOCK >::unsafe_get().