naja_async_runtime 0.5.0-deprecated.1

A lightweight universal runtime for futures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::{ import::* };


/// The error type for errors happening in `async_runtime`.
//
#[ derive( Debug ) ]
//
pub struct Error
{
	kind: ErrorKind,
}

impl StdError for Error {}



/// The different kind of errors that can happen when you use the `async_runtime` API.
//
#[ derive( Copy, Clone, PartialEq, Eq, Debug ) ]
//
pub enum ErrorKind
{
	/// You should not call [init](crate::init) twice on the same thread. In general if you are a library
	/// author, you should not call it unless you started the thread. Otherwise just call [spawn](crate::spawn)
	/// and let the client code decide which executor shall be used.
	/// If you need to call [init](crate::init) several times, you can either verify no executor is set first
	/// (with [current_rt](crate::current_rt)) or use [init_allow_same](crate::init_allow_same)
	//
	DoubleExecutorInit,

	/// A backend error happened while trying to spawn:
	///
	/// - Spawning is infallible on: _juliex_, _async-std_, _bindgen_..
	/// - Spawning on _localpool_ can fail with [`futures::task::SpawnError`](https://rust-lang-nursery.github.io/futures-api-docs/0.3.0-alpha.18/futures/task/struct.SpawnError.html).
	///   The only reason for this is that the executor was shut down. In principle this cannot happen with
	///   async_runtime.
	//
	Spawn,

	/// An error happened when running an executor to completion.
	/// This is returned by tokio_ct::run.
	//
	Run,

	/// When some code in your project (possibly a dependency) uses [`spawn_local`](crate::spawn_local) because
	/// the future they spawn is `!Send`, you must use the localpool for the thread in which this code is run.
	/// It's simply not possible to spawn a `!Send` future on a threadpool.
	//
	SpawnLocalOnThreadPool,

	/// You tried to use a functionality specific to a certain executor while another executor was being
	/// used for this thread.
	//
	WrongExecutor,

	/// You tried to call a spawn function on a thread that has no executor initialized. Please use
	/// [`init`](crate::init) first.
	//
	NoExecutorInitialized,

	/// Protect against adding other options being breaking changes.
	//
	__Nonexhaustive,
}


impl fmt::Display for ErrorKind
{
	fn fmt( &self, f: &mut fmt::Formatter<'_> ) -> fmt::Result
	{
		match self
		{
			Self::DoubleExecutorInit => fmt::Display::fmt( "DoubleExecutorInit: Cannot initialize global executor twice.", f ) ,

			Self::Spawn => fmt::Display::fmt( "Spawn: Failed to spawn a future.", f ) ,

			Self::Run => fmt::Display::fmt( "Run: Failed to run an executor to completion.", f ) ,

			Self::SpawnLocalOnThreadPool => fmt::Display::fmt( "Spawn: You can not spawn `!Send` futures on a thread pool. If your feature is `Send`, use `rt::spawn`, otherwise initialize this thread with a Local executor.", f ) ,

			Self::WrongExecutor => fmt::Display::fmt( "You tried to use a functionality specific to a certain executor while another executor was being used for this thread.", f ) ,

			Self::NoExecutorInitialized => fmt::Display::fmt( "You must initialize an executor on this thread before calls to spawn.", f ) ,

			_ => unreachable!(),
		}
	}
}


impl fmt::Display for Error
{
	fn fmt( &self, f: &mut fmt::Formatter<'_> ) -> fmt::Result
	{
		write!( f, "async_runtime::Error: {}", &self.kind )
	}
}


impl Error
{
	/// Create a new error from a specific kind.
	//
	pub fn new( kind: ErrorKind ) -> Self
	{
		Error { kind }
	}


	/// Allows matching on the error kind.
	//
	pub fn kind( &self ) -> &ErrorKind
	{
		&self.kind
	}
}


impl From<ErrorKind> for Error
{
	fn from( kind: ErrorKind ) -> Error
	{
		Error { kind }
	}
}