bslma_sharedptrinplacerep

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Thread Safety
  • Usage

Purpose

Provide an in-place implementation of bslma::SharedPtrRep.

Classes

• bslma::SharedPtrInplaceRep: in-place bslma::SharedPtrRep implementation

See also

bslma_sharedptr, bslma_sharedptr_rep, bslma_sharedptroutofplacerep

Description

This component provides a concrete implementation of bslma::SharedPtrRep for managing objects of the parameterized TYPE that are stored in-place in the representation . Thus, only one memory allocation is required to create both the representation and the managed object. When all references to the in-place object are released (using releaseRef), the destructor of TYPE is invoked.

Thread Safety

bslma::SharedPtrInplaceRep is thread-safe provided that disposeObject and disposeRep are not called explicitly, meaning that all non-creator operations other than disposeObject and disposeRep on a given instance can be safely invoked simultaneously from multiple threads (disposeObject and disposeRep are meant to be invoked only by releaseRef and releaseWeakRef). Note that there is no thread safety guarantees for operations on the managed object contained in bslma::SharedPtrInplaceRep.

Usage

The following example demonstrates how to implement a shared bdlt::Datetime using bslma::SharedPtrInplaceRep:

class MySharedDatetimePtr {
    // This class provide a reference counted smart pointer to support
    // shared ownership of a 'bdlt::Datetime' object.
 
    bdlt::Datetime      *d_ptr_p;  // pointer to the managed object
    bslma::SharedPtrRep *d_rep_p;  // pointer to the representation object
 
  private:
    // NOT IMPLEMENTED
    MySharedDatetimePtr& operator=(const MySharedDatetimePtr&);
 
  public:
    // CREATORS
    MySharedDatetimePtr();
        // Create an empty shared datetime.
 
    MySharedDatetimePtr(bdlt::Datetime* ptr, bslma::SharedPtrRep* rep);
        // Create a shared datetime that adopts ownership of the specified
        // 'ptr' and the specified 'rep.
 
    MySharedDatetimePtr(const MySharedDatetimePtr& original);
        // Create a shared datetime that refers to the same object managed
        // by the specified 'original'
 
    ~MySharedDatetimePtr();
        // Destroy this shared datetime and release the reference to the
        // 'bdlt::Datetime' object to which it might be referring.  If this
        // is the last shared reference, deleted the managed object.
 
    // MANIPULATORS
    void createInplace(bslma::Allocator *basicAllocator,
                       int               year,
                       int               month,
                       int               day);
        // Create a new 'bslma::SharedPtrInplaceRep', using the specified
        // 'basicAllocator' to supply memory, using the specified 'year',
        // 'month' and 'day' to initialize the 'bdlt::Datetime' within the
        // newly created 'bslma::SharedPtrInplaceRep', and make this
        // object refer to the newly created 'bdlt::Datetime' object.
 
    bdlt::Datetime& operator*() const;
        // Return a reference offering modifiable access to the shared
        // 'bdlt::Datetime' object.
 
    bdlt::Datetime *operator->() const;
        // Return the address of the modifiable 'bdlt::Datetime' to which
        // this object refers.
 
    bdlt::Datetime *ptr() const;
        // Return the address of the modifiable 'bdlt::Datetime' to which
        // this object refers.
};

Finally, we define the implementation.

MySharedDatetimePtr::MySharedDatetimePtr()
: d_ptr_p(0)
, d_rep_p(0)
{
}
 
MySharedDatetimePtr::MySharedDatetimePtr(bdlt::Datetime      *ptr,
                                         bslma::SharedPtrRep *rep)
: d_ptr_p(ptr)
, d_rep_p(rep)
{
}
 
MySharedDatetimePtr::MySharedDatetimePtr(
                                       const MySharedDatetimePtr& original)
: d_ptr_p(original.d_ptr_p)
, d_rep_p(original.d_rep_p)
{
    if (d_ptr_p) {
        d_rep_p->acquireRef();
    } else {
        d_rep_p = 0;
    }
}
 
MySharedDatetimePtr::~MySharedDatetimePtr()
{
    if (d_rep_p) {
        d_rep_p->releaseRef();
    }
}
 
void MySharedDatetimePtr::createInplace(bslma::Allocator *basicAllocator,
                                        int               year,
                                        int               month,
                                        int               day)
{
    basicAllocator = bslma::Default::allocator(basicAllocator);
    bslma::SharedPtrInplaceRep<bdlt::Datetime> *rep = new (*basicAllocator)
                 bslma::SharedPtrInplaceRep<bdlt::Datetime>(basicAllocator,
                                                            year,
                                                            month,
                                                            day);
    MySharedDatetimePtr temp(rep->ptr(), rep);
    bsl::swap(d_ptr_p, temp.d_ptr_p);
    bsl::swap(d_rep_p, temp.d_rep_p);
}
 
bdlt::Datetime& MySharedDatetimePtr::operator*() const {
    return *d_ptr_p;
}
 
bdlt::Datetime *MySharedDatetimePtr::operator->() const {
    return d_ptr_p;
}
 
bdlt::Datetime *MySharedDatetimePtr::ptr() const {
    return d_ptr_p;
}