566 lines
16 KiB
Plaintext
566 lines
16 KiB
Plaintext
|
/*
|
||
|
|
* Copyright 2021 Haiku, Inc. All rights reserved.
|
||
|
|
* Distributed under the terms of the MIT License.
|
||
|
|
*
|
||
|
|
* Authors:
|
||
|
|
* Niels Sascha Reedijk, niels.reedijk@gmail.com
|
||
|
|
*
|
||
|
|
* Corresponds to:
|
||
|
|
* headers/private/netservices2/ExclusiveBorrow.h hrev?????
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
#if __cplusplus >= 201703L
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\file ExclusiveBorrow.h
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Provides the BExclusiveBorrow smart pointer.
|
||
|
|
*/
|
||
|
|
|
||
|
|
namespace BPrivate {
|
||
|
|
|
||
|
|
namespace Network {
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\class BBorrowError
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Error while handling a BExclusiveBorrow or BBorrow object.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrowError::BBorrowError(const char* origin)
|
||
|
|
\brief Constructor that sets the \a origin.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn virtual const char* BBorrowError::Message() const noexcept override
|
||
|
|
\brief Get a pointer to the message describing the borrow error.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
//! \cond INTERNAL
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\class BorrowAdmin
|
||
|
|
\brief Internal class that provides admin block for BExclusiveBorrow and BBorrow.
|
||
|
|
|
||
|
|
This base class provides the admin functions to deal with the underlying objects that are
|
||
|
|
managed by this smart pointers. It is implemented in such a way that it provides type erasure
|
||
|
|
for the actual smart objects, to enable them to allow for a BExclusiveBorrow<Derived> to have a
|
||
|
|
BBorrow<Base> higher up in the class inheritance.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BorrowAdmin::~BorrowAdmin()
|
||
|
|
\brief Destructor
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn virtual void BorrowAdmin::Cleanup() noexcept
|
||
|
|
\brief Hook function that triggers the cleanup of the underlying object.
|
||
|
|
|
||
|
|
Implemented by BorrowPointer<T>
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn virtual void BorrowAdmin::ReleasePointer() noexcept
|
||
|
|
\brief Hook function to relinquish ownership of the underlying pointer.
|
||
|
|
|
||
|
|
When BExclusiveBorrow<T>::Release() is called, ownership of the pointer is transferred to the
|
||
|
|
caller. This hook function allows the BorrowPointer<T> to release the object so that there will
|
||
|
|
not be a double delete when the BExclusiveBorrow<T> is cleaned up.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BorrowAdmin::BorrowAdmin()
|
||
|
|
\brief Constructor
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn void BorrowAdmin::Borrow()
|
||
|
|
\brief Register that a BBorrow<T> object is created
|
||
|
|
|
||
|
|
\exception BBorrowError In case the object already is borrowed.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn void BorrowAdmin::Return() noexcept
|
||
|
|
\brief Register that the BBorrow<T> object no longer borrows the object.
|
||
|
|
|
||
|
|
This also cleans up the internal object if the corresponding BExclusiveBorrow<T> no longer
|
||
|
|
exists.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn void BorrowAdmin::Forfeit() noexcept
|
||
|
|
\brief Register that the BExclusiveBorrow<T> object no longer wants to own the object.
|
||
|
|
|
||
|
|
This also cleans up the internal object if there is no BBorrow<T> object.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn bool BorrowAdmin::IsBorrowed() noexcept
|
||
|
|
\brief Check if the current object is borrowed.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn void BorrowAdmin::Release()
|
||
|
|
\brief Cleanup the BorrowAdmin object without cleaning up the underlying object.
|
||
|
|
|
||
|
|
This method is called by BExclusiveBorrow<T>::Release(), where the smart pointer is emptied and
|
||
|
|
the ownership of the object is transferred to the caller.
|
||
|
|
|
||
|
|
\exception BBorrowError The ownership cannot be released if the object is borrowed.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\class BorrowPointer
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Type derived from BorrowAdmin, which administrates the type-specific pointer.
|
||
|
|
|
||
|
|
In order to accomplish type erasure in BExclusiveBorrow and BBorrow, this derived type handles
|
||
|
|
the actual owned pointer.
|
||
|
|
|
||
|
|
\tparam T The type of the object that the BExclusiveBorrow<T> instance owns.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BorrowPointer<T>::BorrowPointer(T* object) noexcept
|
||
|
|
\brief Construct a new admin block to manage the \a object.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BorrowPointer<T>::~BorrowPointer()
|
||
|
|
\brief Destructor that deletes the owned object.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn virtual void BorrowPointer<T>::Cleanup() noexcept override
|
||
|
|
\brief Implementation of the Cleanup() hook function to delete the admin block and free
|
||
|
|
resources.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn virtual void BorrowPointer<T>::ReleasePointer() noexcept override
|
||
|
|
\brief Implementation of the ReleasePointer() hook function to make sure that the pointer
|
||
|
|
will not be freed when the object is destroyed.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
//! \endcond
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\class BExclusiveBorrow
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Smart pointer that allows shared ownership of an object with exclusive access.
|
||
|
|
|
||
|
|
This smart pointer was designed to support the particular pattern where a non-threadsafe or
|
||
|
|
non-lockable needs to be shared between two threads, where only one can have access to the
|
||
|
|
underlying object at the time.
|
||
|
|
|
||
|
|
When creating a new object, the underlying object can be accessed using the dereference
|
||
|
|
operator overloads as if with any other smart pointer. This ownership can then be borrowed
|
||
|
|
by creating a \ref BBorrow object. At that stage, the original owner can no longer access the
|
||
|
|
underlying object, until the borrow is returned. The borrow can access the object as long as
|
||
|
|
they retain the borrow. The borrow is returned by the borrow object going out of scope, or by
|
||
|
|
the borrow object being assigned a \c nullptr object. At that stage, the original owner regains
|
||
|
|
access.
|
||
|
|
|
||
|
|
\code
|
||
|
|
// Create a newly owned string object.
|
||
|
|
BExclusiveBorrow<BString> owner = make_exclusive_borrow<BString>("Initial value");
|
||
|
|
|
||
|
|
// Access the exclusively accessibe object and set it to a different value
|
||
|
|
owner->SetTo("New value set by owner");
|
||
|
|
|
||
|
|
// Create a borrow.
|
||
|
|
BBorrow<BString> borrow = BBorrow<BString>(owner);
|
||
|
|
|
||
|
|
try {
|
||
|
|
owner->SetTo("Another value set by owner");
|
||
|
|
} catch (const BorrowError& e) {
|
||
|
|
// This error will be thrown because the `owner` cannot access the object while borrowed.
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
BBorrow<BString> secondBorrow = BBorrow<BString>(owner);
|
||
|
|
} catch (const BorrowError& e) {
|
||
|
|
// This error will be thrown because there cannot be more than one borrow at a time.
|
||
|
|
}
|
||
|
|
|
||
|
|
// The `borrow` has exclusive access to the underlying BString object
|
||
|
|
borrow->SetTo("A value set by the borrower");
|
||
|
|
|
||
|
|
// The borrow is returned by explicitly setting it to `nullptr` or by having the object go out
|
||
|
|
// of scope.
|
||
|
|
borrow = nullptr;
|
||
|
|
|
||
|
|
// The owner can access the object again
|
||
|
|
assert(*owner == "A value set by the borrower");
|
||
|
|
\endcode
|
||
|
|
|
||
|
|
\par Object Lifetime Management
|
||
|
|
The BExclusiveBorrow and BBorrow pair manage the lifetime of the underlying object, meaning
|
||
|
|
the memory will be freed when the object is no longer referenced by either the owner or the
|
||
|
|
borrower. It is possible to get the ownership of the underlying object through the
|
||
|
|
\ref BExclusiveBorrow::Release() method. This returns a \c unique_ptr.
|
||
|
|
|
||
|
|
\par Creating New Objects
|
||
|
|
When creating a BExclusiveBorrow object, you can use the \ref BExclusiveBorrow(T* object)
|
||
|
|
constructor to create a new smart pointer that takes an \em existing underlying object. Note
|
||
|
|
that the smart pointer will assume ownership, meaning that you should also have ownership of
|
||
|
|
that object. If you want to create a BExclusiveBorrow object for a new object, then you can use
|
||
|
|
the \ref make_exclusive_borrow() function to create a new object.
|
||
|
|
|
||
|
|
\par Move Semantics and Empty Objects
|
||
|
|
The template class is designed around having an underlying object value, and in most cases will
|
||
|
|
have an underlying object. However, there may be cases where a BExclusiveOwner or BBorrow
|
||
|
|
object will not have an internal value. This either happens when it is explicitly assigned an
|
||
|
|
empty value, or after the object has been moved. You can check whether the object has a value
|
||
|
|
through the \ref HasValue() method. Trying to access an empty object will throw a
|
||
|
|
\ref BBorrowError.
|
||
|
|
|
||
|
|
\par Checked Access
|
||
|
|
The semantics of the exclusive ownership are enforced by this class. The rules are:
|
||
|
|
- There can only be one owner. The object cannot be copied, only moved.
|
||
|
|
- There can only be one borrower at a time. The borrow object cannot be copied, only moved.
|
||
|
|
- If one tries to create an additional borrow, an exception is thrown.
|
||
|
|
- If an object is borrowed, accessing it through the owner will throw exceptions.
|
||
|
|
|
||
|
|
\par Casting Pointers between Owner and Borrower
|
||
|
|
For some design patterns, you may want to be able to cast the type of the owner to a related
|
||
|
|
type for the borrower. For example, the Network Services kit accepts a \c BBorrow<BDataIO> type
|
||
|
|
in order to allow the user to specify where to write the content of a network request to. The
|
||
|
|
\ref BDataIO itself is an abstract interface to read and write data from an object. A user
|
||
|
|
will most likely use a \ref BFile or \ref BMallocIO as underlying objects, both of which
|
||
|
|
have \ref BDataIO as their base class.
|
||
|
|
|
||
|
|
\par
|
||
|
|
Due to the specialized constructor of \ref BBorrow, it is possible to cast between compatible
|
||
|
|
pointer types, without loosing the advantages of properly cleaning up the object when the
|
||
|
|
borrow and the owner go out of scope. In the internals of the template, a type erasure
|
||
|
|
technique similar to that of \c std::shared_ptr is used.
|
||
|
|
|
||
|
|
\code
|
||
|
|
// Create a new BFile object, which inherits the BDataIO class.
|
||
|
|
BExclusiveBorrow<BFile> owner = make_exclusive_borrow<BFile>("path/to/file", B_READ_WRITE);
|
||
|
|
// The following succeeds because a BFile pointer can be assigned to a BDataIO pointer.
|
||
|
|
BBorrow<BDataIO> borrow = BBorrow<BDataIO>(owner);
|
||
|
|
\endcode
|
||
|
|
|
||
|
|
\par Multithread Safety, and Performance Cost
|
||
|
|
This smart object uses atomics to synchronize the ownership and borrows of the object, and to
|
||
|
|
enforce all the checks that were mentioned previously. The atomics guarantee that when you
|
||
|
|
want to access the object in BExclusiveBorrow, that this only succeeds after any outstanding
|
||
|
|
borrow is completed, otherwise an exception is thrown. While atomics can be used as a method of
|
||
|
|
synchronization, this templace class is \em not designed for that and it does not have the
|
||
|
|
tools to help doing that. If you need to synchronize object access between through threads, you
|
||
|
|
should use semaphores or thread joins instead.
|
||
|
|
|
||
|
|
\tparam T The type of object for this smart pointer.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T>::BExclusiveBorrow() noexcept
|
||
|
|
\brief Create a new smart pointer with no value.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T>::BExclusiveBorrow(nullptr_t) noexcept
|
||
|
|
\brief Special constructor that creates a new smart pointer with no value.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T>::BExclusiveBorrow(T* object)
|
||
|
|
\brief Create a new smart pointer that takes ownership of the \a object.
|
||
|
|
|
||
|
|
\param object The object to wrap inside this smart pointer.
|
||
|
|
|
||
|
|
\exception std::bad_alloc In case there are issues allocating memory for the internals of
|
||
|
|
the smart pointer.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T>::~BExclusiveBorrow()
|
||
|
|
\brief Destructor.
|
||
|
|
|
||
|
|
If the smart pointer is not empty, the underlying object will be deleted if there no longer
|
||
|
|
is a borrow accessing it.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T>::BExclusiveBorrow(BExclusiveBorrow&& other) noexcept
|
||
|
|
\brief Move constructor.
|
||
|
|
|
||
|
|
\param other The object to move from. It will be left empty after the move.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow& BExclusiveBorrow<T>::operator=(BExclusiveBorrow&& other) noexcept
|
||
|
|
\brief Move assignment.
|
||
|
|
|
||
|
|
\param other The object to move from. It will be left empty after the move.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn bool BExclusiveBorrow<T>::HasValue() const noexcept
|
||
|
|
\brief Check if the object has a value or is empty.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn T& BExclusiveBorrow<T>::operator*() const
|
||
|
|
\brief Dereferences the pointer.
|
||
|
|
|
||
|
|
\exception BBorrowError This exception is raised if the object is borrowed, or if it is empty.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn T* BExclusiveBorrow<T>::operator->() const
|
||
|
|
\brief Dereferences the pointer.
|
||
|
|
|
||
|
|
\exception BBorrowError This exception is raised if the object is borrowed, or if it is empty.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn std::unique_ptr<T> BExclusiveBorrow<T>::Release()
|
||
|
|
\brief Returns a unique_ptr of the inner object and releases the ownership.
|
||
|
|
|
||
|
|
\exception BBorrowError This exception is raised if the object is borrowed, or if it is empty.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\class BBorrow
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Smart pointer that borrows an object from a \ref BExclusiveBorrow owner.
|
||
|
|
|
||
|
|
The BBorrow smart pointer is the accompanyment to the \ref BExclusiveBorrow owner object. See
|
||
|
|
the documentation on that template class on how to use the smart pointer pairs to express and
|
||
|
|
enforce exclusive ownership between the owner and the borrower.
|
||
|
|
|
||
|
|
Like a BExclusiveBorrow object, a BBorrow object can either have a borrow or be empty. When it
|
||
|
|
is empty, it means the current object is not borrowing anything at that moment. Any calls to
|
||
|
|
access the underlying data will fail in that case.
|
||
|
|
|
||
|
|
\tparam T The type of object that is owned by this smart pointer.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow<T>::BBorrow() noexcept
|
||
|
|
\brief Create a new smart pointer with no value.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow<T>::BBorrow(nullptr_t) noexcept
|
||
|
|
\brief Special constructor that builds an empty borrow object.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow<T>::BBorrow(BExclusiveBorrow<P>& owner)
|
||
|
|
\brief Construct a borrowed object from the \a owner.
|
||
|
|
|
||
|
|
\param owner The owner to borrow from.
|
||
|
|
|
||
|
|
\exception BBorrowError In case the \a owner already borrowed their object, or in case the
|
||
|
|
\a owner is an empty object, as you cannot borrow something that is not there.
|
||
|
|
|
||
|
|
\tparam T The type of object for this BBorrow object.
|
||
|
|
\tparam P The type of objedt for the BExclusiveBorrow object. This allows you to have different
|
||
|
|
types between the owner and the borrower, with the requirement that a pointer to type P can
|
||
|
|
be cast to a pointer of type T without issue.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow<T>::BBorrow(BBorrow&& other) noexcept
|
||
|
|
\brief Move constructor.
|
||
|
|
|
||
|
|
\param other The object to move from. It will be left empty after the move.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow& BBorrow<T>::operator=(BBorrow&& other) noexcept
|
||
|
|
\brief Move assignment.
|
||
|
|
|
||
|
|
\param other The object to move from. It will be left empty after the move.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BBorrow<T>::~BBorrow()
|
||
|
|
\brief Destructor that returns the object to the original owner.
|
||
|
|
|
||
|
|
If the original owner no longer exists, the underlying object will be deleted.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn bool BBorrow<T>::HasValue() const noexcept
|
||
|
|
\brief Check if the object has a value or is empty.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn T& BBorrow<T>::operator*() const
|
||
|
|
\brief Dereference operator.
|
||
|
|
|
||
|
|
\exception BBorrowError When the smart pointer is empty and there is no object to access.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn T* BBorrow<T>::operator->() const
|
||
|
|
\brief Dereference operator.
|
||
|
|
|
||
|
|
\exception BBorrowError When the smart pointer is empty and there is no object to access.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn void BBorrow<T>::Return() noexcept
|
||
|
|
\brief Return object to the owner.
|
||
|
|
|
||
|
|
The current object will be set to be an empty object after this call. If the object is already
|
||
|
|
empty, this call will not do anything. If the owner no longer exists, the object will be
|
||
|
|
disposed off.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
/*!
|
||
|
|
\fn BExclusiveBorrow<T> make_exclusive_borrow(_Args&& ...__args)
|
||
|
|
\ingroup netservices
|
||
|
|
\brief Create a new object that is managed by a BExclusiveBorrow smart pointer.
|
||
|
|
|
||
|
|
This is a convenience template function to the likes of \c std::make_unique(). It allows you to
|
||
|
|
directly create the \ref BExclusiveBorrow smart pointer around a newly allocated object.
|
||
|
|
|
||
|
|
\tparam T The type of the object that will be created.
|
||
|
|
\tparam _Args Arguments to be passed to the constructor of T.
|
||
|
|
|
||
|
|
\exception std::bad_alloc In case there are issues allocating the new object.
|
||
|
|
\exception ... Any other exception that is thrown by the constructor of the object T.
|
||
|
|
|
||
|
|
\since Haiku R1
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
} // namespace Network
|
||
|
|
|
||
|
|
} // namespace BPrivate
|
||
|
|
|
||
|
|
# endif
|