pub unsafe fn from_ot_ptr(ptr: *mut T::OtType) -> Option<Self> {
        if ptr.is_null() {
            None
        } else {
            Some(Box(ptr, Default::default()))
        }
    }
/// Takes ownership of an OpenThread object by wrapping it in an `OtBox` instance.
/// Unless subsequently removed by a call to [`take_ot_ptr()`], the pointed-to
/// object will be finalized when the box goes out of scope.
///
/// ## Safety ##
///
/// This method is unsafe because it is effectively a deferred call
/// to [`Boxable::ref_from_ot_ptr`], which is also unsafe. When calling,
/// care must be taken to ensure the following is true:
///
/// 1. The given pointer points to a valid instance of `T::OtType`.
/// 2. The caller has logical ownership of the object being pointed to.
Takes ownership of an OpenThread object by wrapping it in an `OtBox` instance.
Unless subsequently removed by a call to [`take_ot_ptr()`], the pointed-to
object will be finalized when the box goes out of scope.
Takes ownership of an OpenThread object by wrapping it in an ` OtBox ` instance . Unless subsequently removed by a call to [ ` take_ot_ptr () ` ] the pointed - to object will be finalized when the box goes out of scope .
pub unsafe fn from_ot_ptr(ptr: *mut T::OtType) -> Option<Self> {
        if ptr.is_null() {
            None
        } else {
            Some(Box(ptr, Default::default()))
        }
    }
pub unsafe fn from_ot_ptr ( ptr : * mut T :: OtType ) -> Option < Self > { if ptr . is_null ( ) { None } else { Some ( Box ( ptr , Default :: default ( ) ) ) } }
Takes ownership of an OpenThread object by wrapping it in an `OtBox` instance.
Takes ownership of an OpenThread object by wrapping it in an ` OtBox ` instance .
ptr
*mut T::OtType
ptr
*mut T::OtType
safety 
This method is unsafe because it is effectively a deferred call
to [`Boxable::ref_from_ot_ptr`], which is also unsafe. When calling,
care must be taken to ensure the following is true.

1. The given pointer points to a valid instance of `T::OtType`.
2. The caller has logical ownership of the object being pointed to.
This method is unsafe because it is effectively a deferred call to [ ` Boxable :: ref_from_ot_ptr ` ] which is also unsafe . When calling care must be taken to ensure the following is true . 1 . The given pointer points to a valid instance of ` T :: OtType ` . 2 . The caller has logical ownership of the object being pointed to .