pub fn detach( mut self )
	{
		match &mut self.inner
		{
			#[ cfg(any( feature = "tokio_tp", feature = "tokio_ct" )) ]
			//
			InnerJh::Tokio{ ref mut detached, .. } =>
			{
				// only other use of this is in Drop impl and we consume self here,
				// so there cannot be any race as this does not sync things across threads,
				// hence Relaxed ordering.
				//
				*detached = true;
			}

			#[ cfg( feature = "async_global" ) ] InnerJh::AsyncGlobal{ task } =>
			{
				let task = task.take();
				task.unwrap().detach();
			}

			#[ cfg( feature = "async_std" ) ] InnerJh::AsyncStd{ ref mut detached, .. } =>
			{
				*detached = true;
			}

			InnerJh::RemoteHandle{ handle } =>
			{
				if let Some(rh) = handle.take() { rh.forget() };
			}
		}
	}
/// Drops this handle without canceling the underlying future.
///
/// This method can be used if you want to drop the handle, but let the execution continue.
//
Drops this handle without canceling the underlying future.
This method can be used if you want to drop the handle, but let the execution continue.
Drops this handle without canceling the underlying future . This method can be used if you want to drop the handle but let the execution continue .
pub fn detach( mut self )
	{
		match &mut self.inner
		{
			#[ cfg(any( feature = "tokio_tp", feature = "tokio_ct" )) ]
			//
			InnerJh::Tokio{ ref mut detached, .. } =>
			{
				// only other use of this is in Drop impl and we consume self here,
				// so there cannot be any race as this does not sync things across threads,
				// hence Relaxed ordering.
				//
				*detached = true;
			}
			#[ cfg( feature = "async_global" ) ] InnerJh::AsyncGlobal{ task } =>
			{
				let task = task.take();
				task.unwrap().detach();
			}
			#[ cfg( feature = "async_std" ) ] InnerJh::AsyncStd{ ref mut detached, .. } =>
			{
				*detached = true;
			}
			InnerJh::RemoteHandle{ handle } =>
			{
				if let Some(rh) = handle.take() { rh.forget() };
			}
		}
	}
pub fn detach ( mut self ) { match & mut self . inner { # [ cfg ( any ( feature " " feature " " ) ) ] // InnerJh :: Tokio { ref mut detached , .. } => { // only other use of this is in Drop impl and we consume self here, // so there cannot be any race as this does not sync things across threads, // hence Relaxed ordering. // * detached = true ; } # [ cfg ( feature " " ) ] InnerJh :: AsyncGlobal { task } => { let task = task . take ( ) ; task . unwrap ( ) . detach ( ) ; } # [ cfg ( feature " " ) ] InnerJh :: AsyncStd { ref mut detached , .. } => { * detached = true ; } InnerJh :: RemoteHandle { handle } => { if let Some ( rh ) = handle . take ( ) { rh . forget ( ) } ; } } }
Drops this handle without canceling the underlying future.
Drops this handle without canceling the underlying future .
mut self
mut self