pub fn new() -> Self {
        Self {
            target: MAGIC_OWNER_ID_TARGET,
            _marker: PhantomPinned,
        }
    }
/// Create an owner that can be used for creating many `QCell`
/// instances.  After this value is pinned it will have a temporally
/// unique ID associated with it to detect using the wrong owner to
/// access a cell at runtime, which is a programming error.
///
/// Given the safety contract of Pin, this safe version does
/// successfully defend against all malicious and unsafe use, as far
/// as I am aware.  If not, please raise an issue.  The same unique
/// ID may later be allocated to someone else once you drop the
/// returned owner, but this cannot be abused to cause unsafe access
/// to cells because there will still be only one owner active at
/// any one time with that ID.  Also it cannot be used maliciously
/// to access cells which don't belong to the new caller, because
/// you also need a reference to the cells.  So for example if you
/// have a graph of cells that is only accessible through a
/// private structure, then someone else getting the same owner ID
/// makes no difference, because they have no way to get a
/// reference to those cells.  In any case, you are probably going
/// to drop all those cells at the same time as dropping the
/// owner, because they are no longer of any use without the owner
/// ID.
Create an owner that can be used for creating many `QCell`
instances.  After this value is pinned it will have a temporally
unique ID associated with it to detect using the wrong owner to
access a cell at runtime, which is a programming error.

Given the safety contract of Pin, this safe version does
successfully defend against all malicious and unsafe use, as far
as I am aware.  If not, please raise an issue.  The same unique
ID may later be allocated to someone else once you drop the
returned owner, but this cannot be abused to cause unsafe access
to cells because there will still be only one owner active at
any one time with that ID.  Also it cannot be used maliciously
to access cells which don't belong to the new caller, because
you also need a reference to the cells.  So for example if you
have a graph of cells that is only accessible through a
private structure, then someone else getting the same owner ID
makes no difference, because they have no way to get a
reference to those cells.  In any case, you are probably going
to drop all those cells at the same time as dropping the
owner, because they are no longer of any use without the owner
ID.
Create an owner that can be used for creating many ` QCell ` instances . After this value is pinned it will have a temporally unique ID associated with it to detect using the wrong owner to access a cell at runtime which is a programming error . Given the safety contract of Pin this safe version does successfully defend against all malicious and unsafe use as far as I am aware . If not please raise an issue . The same unique ID may later be allocated to someone else once you drop the returned owner but this cannot be abused to cause unsafe access to cells because there will still be only one owner active at any one time with that ID . Also it cannot be used maliciously to access cells which don ' t belong to the new caller because you also need a reference to the cells . So for example if you have a graph of cells that is only accessible through a private structure then someone else getting the same owner ID makes no difference because they have no way to get a reference to those cells . In any case you are probably going to drop all those cells at the same time as dropping the owner because they are no longer of any use without the owner ID .
pub fn new() -> Self {
        Self {
            target: MAGIC_OWNER_ID_TARGET,
            _marker: PhantomPinned,
        }
    }
pub fn new ( ) -> Self { Self { target : MAGIC_OWNER_ID_TARGET , _marker : PhantomPinned , } }
Create an owner that can be used for creating many `QCell`
instances.
Create an owner that can be used for creating many ` QCell ` instances .