您最多选择25个主题 主题必须以中文或者字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符
 
 
 
 
 
 

1050 行
44 KiB

using System;
using System.Collections;
using System.Runtime.ExceptionServices;
using System.Runtime.Serialization;
using Unity.UIWidgets.foundation;
using UnityEngine;
namespace Unity.UIWidgets.async {
public delegate object ZoneCallback();
public delegate object ZoneUnaryCallback(object arg);
public delegate object ZoneBinaryCallback(object arg1, object arg2);
public delegate void HandleUncaughtErrorHandler(Zone self, ZoneDelegate parent, Zone zone, Exception error);
public delegate object RunHandler(
Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f);
public delegate object RunUnaryHandler(
Zone self, ZoneDelegate parent, Zone zone, ZoneUnaryCallback f, object arg);
public delegate object RunBinaryHandler(Zone self, ZoneDelegate parent,
Zone zone, ZoneBinaryCallback f, object arg1, object arg2);
public delegate ZoneCallback RegisterCallbackHandler(
Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f);
public delegate ZoneUnaryCallback RegisterUnaryCallbackHandler(
Zone self, ZoneDelegate parent, Zone zone, ZoneUnaryCallback f);
public delegate ZoneBinaryCallback RegisterBinaryCallbackHandler(Zone self,
ZoneDelegate parent, Zone zone, ZoneBinaryCallback f);
public delegate AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent,
Zone zone, Exception error);
public delegate void ScheduleMicrotaskHandler(
Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f);
public delegate Timer CreateTimerHandler(
Zone self, ZoneDelegate parent, Zone zone, TimeSpan duration, ZoneCallback f);
public delegate Timer CreatePeriodicTimerHandler(Zone self, ZoneDelegate parent,
Zone zone, TimeSpan period, ZoneUnaryCallback f);
public delegate void PrintHandler(
Zone self, ZoneDelegate parent, Zone zone, string line);
public delegate Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone,
ZoneSpecification specification, Hashtable zoneValues);
public class AsyncError : Exception {
public AsyncError() {
}
protected AsyncError(SerializationInfo info, StreamingContext context) : base(info, context) {
}
public AsyncError(string message) : base(message) {
}
public AsyncError(string message, Exception innerException) : base(message, innerException) {
}
public AsyncError(Exception innerException) : base(null, innerException) {
}
}
struct _ZoneFunction<T> where T : Delegate {
public readonly _Zone zone;
public readonly T function;
internal _ZoneFunction(_Zone zone, T function) {
this.zone = zone;
this.function = function;
}
}
struct _RunNullaryZoneFunction {
public readonly _Zone zone;
public readonly RunHandler function;
internal _RunNullaryZoneFunction(_Zone zone, RunHandler function) {
this.zone = zone;
this.function = function;
}
}
struct _RunUnaryZoneFunction {
public readonly _Zone zone;
public readonly RunUnaryHandler function;
internal _RunUnaryZoneFunction(_Zone zone, RunUnaryHandler function) {
this.zone = zone;
this.function = function;
}
}
struct _RunBinaryZoneFunction {
public readonly _Zone zone;
public readonly RunBinaryHandler function;
internal _RunBinaryZoneFunction(_Zone zone, RunBinaryHandler function) {
this.zone = zone;
this.function = function;
}
}
struct _RegisterNullaryZoneFunction {
public readonly _Zone zone;
public readonly RegisterCallbackHandler function;
internal _RegisterNullaryZoneFunction(_Zone zone, RegisterCallbackHandler function) {
this.zone = zone;
this.function = function;
}
}
struct _RegisterUnaryZoneFunction {
public readonly _Zone zone;
public readonly RegisterUnaryCallbackHandler function;
internal _RegisterUnaryZoneFunction(_Zone zone, RegisterUnaryCallbackHandler function) {
this.zone = zone;
this.function = function;
}
}
struct _RegisterBinaryZoneFunction {
public readonly _Zone zone;
public readonly RegisterBinaryCallbackHandler function;
internal _RegisterBinaryZoneFunction(_Zone zone, RegisterBinaryCallbackHandler function) {
this.zone = zone;
this.function = function;
}
}
public class ZoneSpecification {
public ZoneSpecification(
HandleUncaughtErrorHandler handleUncaughtError = null,
RunHandler run = null,
RunUnaryHandler runUnary = null,
RunBinaryHandler runBinary = null,
RegisterCallbackHandler registerCallback = null,
RegisterUnaryCallbackHandler registerUnaryCallback = null,
RegisterBinaryCallbackHandler registerBinaryCallback = null,
ErrorCallbackHandler errorCallback = null,
ScheduleMicrotaskHandler scheduleMicrotask = null,
CreateTimerHandler createTimer = null,
CreatePeriodicTimerHandler createPeriodicTimer = null,
PrintHandler print = null,
ForkHandler fork = null) {
this.handleUncaughtError = handleUncaughtError;
this.run = run;
this.runUnary = runUnary;
this.runBinary = runBinary;
this.registerCallback = registerCallback;
this.registerUnaryCallback = registerUnaryCallback;
this.registerBinaryCallback = registerBinaryCallback;
this.errorCallback = errorCallback;
this.scheduleMicrotask = scheduleMicrotask;
this.createTimer = createTimer;
this.createPeriodicTimer = createPeriodicTimer;
this.print = print;
this.fork = fork;
}
public static ZoneSpecification from(
ZoneSpecification other,
HandleUncaughtErrorHandler handleUncaughtError = null,
RunHandler run = null,
RunUnaryHandler runUnary = null,
RunBinaryHandler runBinary = null,
RegisterCallbackHandler registerCallback = null,
RegisterUnaryCallbackHandler registerUnaryCallback = null,
RegisterBinaryCallbackHandler registerBinaryCallback = null,
ErrorCallbackHandler errorCallback = null,
ScheduleMicrotaskHandler scheduleMicrotask = null,
CreateTimerHandler createTimer = null,
CreatePeriodicTimerHandler createPeriodicTimer = null,
PrintHandler print = null,
ForkHandler fork = null) {
return new ZoneSpecification(
handleUncaughtError: handleUncaughtError ?? other.handleUncaughtError,
run: run ?? other.run,
runUnary: runUnary ?? other.runUnary,
runBinary: runBinary ?? other.runBinary,
registerCallback: registerCallback ?? other.registerCallback,
registerUnaryCallback:
registerUnaryCallback ?? other.registerUnaryCallback,
registerBinaryCallback:
registerBinaryCallback ?? other.registerBinaryCallback,
errorCallback: errorCallback ?? other.errorCallback,
scheduleMicrotask: scheduleMicrotask ?? other.scheduleMicrotask,
createTimer: createTimer ?? other.createTimer,
createPeriodicTimer: createPeriodicTimer ?? other.createPeriodicTimer,
print: print ?? other.print,
fork: fork ?? other.fork
);
}
public HandleUncaughtErrorHandler handleUncaughtError { get; }
public RunHandler run { get; }
public RunUnaryHandler runUnary { get; }
public RunBinaryHandler runBinary { get; }
public RegisterCallbackHandler registerCallback { get; }
public RegisterUnaryCallbackHandler registerUnaryCallback { get; }
public RegisterBinaryCallbackHandler registerBinaryCallback { get; }
public ErrorCallbackHandler errorCallback { get; }
public ScheduleMicrotaskHandler scheduleMicrotask { get; }
public CreateTimerHandler createTimer { get; }
public CreatePeriodicTimerHandler createPeriodicTimer { get; }
public PrintHandler print { get; }
public ForkHandler fork { get; }
}
public interface ZoneDelegate {
void handleUncaughtError(Zone zone, Exception error);
object run(Zone zone, ZoneCallback f);
object runUnary(Zone zone, ZoneUnaryCallback f, object arg);
object runBinary(Zone zone, ZoneBinaryCallback f, object arg1, object arg2);
ZoneCallback registerCallback(Zone zone, ZoneCallback f);
ZoneUnaryCallback registerUnaryCallback(Zone zone, ZoneUnaryCallback f);
ZoneBinaryCallback registerBinaryCallback(Zone zone, ZoneBinaryCallback f);
AsyncError errorCallback(Zone zone, Exception error);
void scheduleMicrotask(Zone zone, ZoneCallback f);
Timer createTimer(Zone zone, TimeSpan duration, ZoneCallback f);
Timer createPeriodicTimer(Zone zone, TimeSpan period, ZoneUnaryCallback f);
void print(Zone zone, string line);
Zone fork(Zone zone, ZoneSpecification specification, Hashtable zoneValues);
}
public abstract class Zone {
protected Zone() {
}
public static readonly Zone root = async_._rootZone;
internal static Zone _current = async_._rootZone;
public static Zone current => _current;
public abstract void handleUncaughtError(Exception error);
public abstract Zone parent { get; }
public abstract Zone errorZone { get; }
public abstract bool inSameErrorZone(Zone otherZone);
public abstract Zone fork(ZoneSpecification specification = null, Hashtable zoneValues = null);
public abstract object run(ZoneCallback action);
public abstract object runUnary(ZoneUnaryCallback action, object argument);
public abstract object runBinary(ZoneBinaryCallback action, object argument1, object argument2);
public abstract object runGuarded(ZoneCallback action);
public abstract object runUnaryGuarded(ZoneUnaryCallback action, object argument);
public abstract object runBinaryGuarded(ZoneBinaryCallback action, object argument1, object argument2);
public abstract ZoneCallback registerCallback(ZoneCallback callback);
public abstract ZoneUnaryCallback registerUnaryCallback(ZoneUnaryCallback callback);
public abstract ZoneBinaryCallback registerBinaryCallback(ZoneBinaryCallback fcallback);
public abstract ZoneCallback bindCallback(ZoneCallback callback);
public abstract ZoneUnaryCallback bindUnaryCallback(ZoneUnaryCallback callback);
public abstract ZoneBinaryCallback bindBinaryCallback(ZoneBinaryCallback callback);
public abstract ZoneCallback bindCallbackGuarded(ZoneCallback callback);
public abstract ZoneUnaryCallback bindUnaryCallbackGuarded(ZoneUnaryCallback callback);
public abstract ZoneBinaryCallback bindBinaryCallbackGuarded(ZoneBinaryCallback callback);
public abstract AsyncError errorCallback(Exception error);
public abstract void scheduleMicrotask(ZoneCallback callback);
public abstract Timer createTimer(TimeSpan duration, ZoneCallback callback);
public abstract Timer createPeriodicTimer(TimeSpan period, ZoneUnaryCallback callback);
public abstract void print(string line);
internal static Zone _enter(Zone zone) {
D.assert(zone != null);
D.assert(!ReferenceEquals(zone, _current));
Zone previous = _current;
_current = zone;
return previous;
}
internal static void _leave(Zone previous) {
D.assert(previous != null);
_current = previous;
}
public abstract object this[object key] { get; }
}
public static partial class async_ {
internal static ZoneDelegate _parentDelegate(_Zone zone) {
if (zone.parent == null) return null;
return zone._parent._delegate;
}
}
class _ZoneDelegate : ZoneDelegate {
readonly _Zone _delegationTarget;
internal _ZoneDelegate(_Zone delegationTarget) {
_delegationTarget = delegationTarget;
}
public void handleUncaughtError(Zone zone, Exception error) {
var implementation = _delegationTarget._handleUncaughtError;
_Zone implZone = implementation.zone;
HandleUncaughtErrorHandler handler = implementation.function;
handler(implZone, async_._parentDelegate(implZone), zone, error);
}
public object run(Zone zone, ZoneCallback f) {
var implementation = _delegationTarget._run;
_Zone implZone = implementation.zone;
RunHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f);
}
public object runUnary(Zone zone, ZoneUnaryCallback f, object arg) {
var implementation = _delegationTarget._runUnary;
_Zone implZone = implementation.zone;
RunUnaryHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f, arg);
}
public object runBinary(Zone zone, ZoneBinaryCallback f, object arg1, object arg2) {
var implementation = _delegationTarget._runBinary;
_Zone implZone = implementation.zone;
RunBinaryHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f, arg1, arg2);
}
public ZoneCallback registerCallback(Zone zone, ZoneCallback f) {
var implementation = _delegationTarget._registerCallback;
_Zone implZone = implementation.zone;
RegisterCallbackHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f);
}
public ZoneUnaryCallback registerUnaryCallback(Zone zone, ZoneUnaryCallback f) {
var implementation = _delegationTarget._registerUnaryCallback;
_Zone implZone = implementation.zone;
RegisterUnaryCallbackHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f);
}
public ZoneBinaryCallback registerBinaryCallback(Zone zone, ZoneBinaryCallback f) {
var implementation = _delegationTarget._registerBinaryCallback;
_Zone implZone = implementation.zone;
RegisterBinaryCallbackHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, f);
}
public AsyncError errorCallback(Zone zone, Exception error) {
if (error == null)
throw new ArgumentNullException(nameof(error));
var implementation = _delegationTarget._errorCallback;
_Zone implZone = implementation.zone;
if (ReferenceEquals(implZone, async_._rootZone)) return null;
ErrorCallbackHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, error);
}
public void scheduleMicrotask(Zone zone, ZoneCallback f) {
var implementation = _delegationTarget._scheduleMicrotask;
_Zone implZone = implementation.zone;
ScheduleMicrotaskHandler handler = implementation.function;
handler(implZone, async_._parentDelegate(implZone), zone, f);
}
public Timer createTimer(Zone zone, TimeSpan duration, ZoneCallback f) {
var implementation = _delegationTarget._createTimer;
_Zone implZone = implementation.zone;
CreateTimerHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, duration, f);
}
public Timer createPeriodicTimer(Zone zone, TimeSpan period, ZoneUnaryCallback f) {
var implementation = _delegationTarget._createPeriodicTimer;
_Zone implZone = implementation.zone;
CreatePeriodicTimerHandler handler = implementation.function;
return handler(implZone, async_._parentDelegate(implZone), zone, period, f);
}
public void print(Zone zone, string line) {
var implementation = _delegationTarget._print;
_Zone implZone = implementation.zone;
PrintHandler handler = implementation.function;
handler(implZone, async_._parentDelegate(implZone), zone, line);
}
public Zone fork(Zone zone, ZoneSpecification specification, Hashtable zoneValues) {
var implementation = _delegationTarget._fork;
_Zone implZone = implementation.zone;
ForkHandler handler = implementation.function;
return handler(
implZone, async_._parentDelegate(implZone), zone, specification, zoneValues);
}
}
abstract class _Zone : Zone {
protected _Zone() {
}
internal abstract _RunNullaryZoneFunction _run { get; }
internal abstract _RunUnaryZoneFunction _runUnary { get; }
internal abstract _RunBinaryZoneFunction _runBinary { get; }
internal abstract _RegisterNullaryZoneFunction _registerCallback { get; }
internal abstract _RegisterUnaryZoneFunction _registerUnaryCallback { get; }
internal abstract _RegisterBinaryZoneFunction _registerBinaryCallback { get; }
internal abstract _ZoneFunction<ErrorCallbackHandler> _errorCallback { get; }
internal abstract _ZoneFunction<ScheduleMicrotaskHandler> _scheduleMicrotask { get; }
internal abstract _ZoneFunction<CreateTimerHandler> _createTimer { get; }
internal abstract _ZoneFunction<CreatePeriodicTimerHandler> _createPeriodicTimer { get; }
internal abstract _ZoneFunction<PrintHandler> _print { get; }
internal abstract _ZoneFunction<ForkHandler> _fork { get; }
internal abstract _ZoneFunction<HandleUncaughtErrorHandler> _handleUncaughtError { get; }
internal abstract ZoneDelegate _delegate { get; }
internal abstract Hashtable _map { get; }
internal abstract _Zone _parent { get; }
public override Zone parent => _parent;
public override bool inSameErrorZone(Zone otherZone) {
return ReferenceEquals(this, otherZone) ||
ReferenceEquals(errorZone, otherZone.errorZone);
}
}
class _CustomZone : _Zone {
internal override _RunNullaryZoneFunction _run { get; }
internal override _RunUnaryZoneFunction _runUnary { get; }
internal override _RunBinaryZoneFunction _runBinary { get; }
internal override _RegisterNullaryZoneFunction _registerCallback { get; }
internal override _RegisterUnaryZoneFunction _registerUnaryCallback { get; }
internal override _RegisterBinaryZoneFunction _registerBinaryCallback { get; }
internal override _ZoneFunction<ErrorCallbackHandler> _errorCallback { get; }
internal override _ZoneFunction<ScheduleMicrotaskHandler> _scheduleMicrotask { get; }
internal override _ZoneFunction<CreateTimerHandler> _createTimer { get; }
internal override _ZoneFunction<CreatePeriodicTimerHandler> _createPeriodicTimer { get; }
internal override _ZoneFunction<PrintHandler> _print { get; }
internal override _ZoneFunction<ForkHandler> _fork { get; }
internal override _ZoneFunction<HandleUncaughtErrorHandler> _handleUncaughtError { get; }
ZoneDelegate _delegateCache;
internal override _Zone _parent { get; }
internal override Hashtable _map { get; }
internal override ZoneDelegate _delegate {
get {
if (_delegateCache != null) return _delegateCache;
_delegateCache = new _ZoneDelegate(this);
return _delegateCache;
}
}
internal _CustomZone(_Zone parent, ZoneSpecification specification, Hashtable map) {
_parent = parent;
_map = map;
_run = (specification.run != null)
? new _RunNullaryZoneFunction(this, specification.run)
: parent._run;
_runUnary = (specification.runUnary != null)
? new _RunUnaryZoneFunction(this, specification.runUnary)
: parent._runUnary;
_runBinary = (specification.runBinary != null)
? new _RunBinaryZoneFunction(this, specification.runBinary)
: parent._runBinary;
_registerCallback = (specification.registerCallback != null)
? new _RegisterNullaryZoneFunction(this, specification.registerCallback)
: parent._registerCallback;
_registerUnaryCallback = (specification.registerUnaryCallback != null)
? new _RegisterUnaryZoneFunction(
this, specification.registerUnaryCallback)
: parent._registerUnaryCallback;
_registerBinaryCallback = (specification.registerBinaryCallback != null)
? new _RegisterBinaryZoneFunction(
this, specification.registerBinaryCallback)
: parent._registerBinaryCallback;
_errorCallback = (specification.errorCallback != null)
? new _ZoneFunction<ErrorCallbackHandler>(
this, specification.errorCallback)
: parent._errorCallback;
_scheduleMicrotask = (specification.scheduleMicrotask != null)
? new _ZoneFunction<ScheduleMicrotaskHandler>(
this, specification.scheduleMicrotask)
: parent._scheduleMicrotask;
_createTimer = (specification.createTimer != null)
? new _ZoneFunction<CreateTimerHandler>(this, specification.createTimer)
: parent._createTimer;
_createPeriodicTimer = (specification.createPeriodicTimer != null)
? new _ZoneFunction<CreatePeriodicTimerHandler>(
this, specification.createPeriodicTimer)
: parent._createPeriodicTimer;
_print = (specification.print != null)
? new _ZoneFunction<PrintHandler>(this, specification.print)
: parent._print;
_fork = (specification.fork != null)
? new _ZoneFunction<ForkHandler>(this, specification.fork)
: parent._fork;
_handleUncaughtError = (specification.handleUncaughtError != null)
? new _ZoneFunction<HandleUncaughtErrorHandler>(
this, specification.handleUncaughtError)
: parent._handleUncaughtError;
}
public override Zone errorZone => _handleUncaughtError.zone;
public override object runGuarded(ZoneCallback f) {
try {
return run(f);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override object runUnaryGuarded(ZoneUnaryCallback f, object arg) {
try {
return runUnary(f, arg);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override object runBinaryGuarded(ZoneBinaryCallback f, object arg1, object arg2) {
try {
return runBinary(f, arg1, arg2);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override ZoneCallback bindCallback(ZoneCallback f) {
var registered = registerCallback(f);
return () => run(registered);
}
public override ZoneUnaryCallback bindUnaryCallback(ZoneUnaryCallback f) {
var registered = registerUnaryCallback(f);
return (arg) => runUnary(registered, arg);
}
public override ZoneBinaryCallback bindBinaryCallback(ZoneBinaryCallback f) {
var registered = registerBinaryCallback(f);
return (arg1, arg2) => runBinary(registered, arg1, arg2);
}
public override ZoneCallback bindCallbackGuarded(ZoneCallback f) {
var registered = registerCallback(f);
return () => runGuarded(registered);
}
public override ZoneUnaryCallback bindUnaryCallbackGuarded(ZoneUnaryCallback f) {
var registered = registerUnaryCallback(f);
return (arg) => runUnaryGuarded(registered, arg);
}
public override ZoneBinaryCallback bindBinaryCallbackGuarded(ZoneBinaryCallback f) {
var registered = registerBinaryCallback(f);
return (arg1, arg2) => runBinaryGuarded(registered, arg1, arg2);
}
public override object this[object key] {
get {
var result = _map[key];
if (result != null || _map.ContainsKey(key)) return result;
// If we are not the root zone, look up in the parent zone.
if (parent != null) {
// We do not optimize for repeatedly looking up a key which isn't
// there. That would require storing the key and keeping it alive.
// Copying the key/value from the parent does not keep any new values
// alive.
var value = parent[key];
if (value != null) {
_map[key] = value;
}
return value;
}
D.assert(this == async_._rootZone);
return null;
}
}
public override void handleUncaughtError(Exception error) {
var implementation = _handleUncaughtError;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
HandleUncaughtErrorHandler handler = implementation.function;
handler(implementation.zone, parentDelegate, this, error);
}
public override Zone fork(ZoneSpecification specification = null, Hashtable zoneValues = null) {
var implementation = _fork;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
ForkHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, specification, zoneValues);
}
public override object run(ZoneCallback f) {
var implementation = _run;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RunHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, f);
}
public override object runUnary(ZoneUnaryCallback f, object arg) {
var implementation = _runUnary;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RunUnaryHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, f, arg);
}
public override object runBinary(ZoneBinaryCallback f, object arg1, object arg2) {
var implementation = _runBinary;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RunBinaryHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, f, arg1, arg2);
}
public override ZoneCallback registerCallback(ZoneCallback callback) {
var implementation = _registerCallback;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RegisterCallbackHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, callback);
}
public override ZoneUnaryCallback registerUnaryCallback(ZoneUnaryCallback callback) {
var implementation = _registerUnaryCallback;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RegisterUnaryCallbackHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, callback);
}
public override ZoneBinaryCallback registerBinaryCallback(ZoneBinaryCallback callback) {
var implementation = _registerBinaryCallback;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RegisterBinaryCallbackHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, callback);
}
public override AsyncError errorCallback(Exception error) {
if (error == null)
throw new ArgumentNullException(nameof(error));
var implementation = _errorCallback;
_Zone implementationZone = implementation.zone;
if (ReferenceEquals(implementationZone, async_._rootZone)) return null;
ZoneDelegate parentDelegate = async_._parentDelegate(implementationZone);
ErrorCallbackHandler handler = implementation.function;
return handler(implementationZone, parentDelegate, this, error);
}
public override void scheduleMicrotask(ZoneCallback f) {
var implementation = _scheduleMicrotask;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
ScheduleMicrotaskHandler handler = implementation.function;
handler(implementation.zone, parentDelegate, this, f);
}
public override Timer createTimer(TimeSpan duration, ZoneCallback f) {
var implementation = _createTimer;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
CreateTimerHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, duration, f);
}
public override Timer createPeriodicTimer(TimeSpan duration, ZoneUnaryCallback f) {
var implementation = _createPeriodicTimer;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
CreatePeriodicTimerHandler handler = implementation.function;
return handler(implementation.zone, parentDelegate, this, duration, f);
}
public override void print(string line) {
var implementation = _print;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
PrintHandler handler = implementation.function;
handler(implementation.zone, parentDelegate, this, line);
}
}
public static partial class async_ {
public static void _rootHandleUncaughtError(
Zone self, ZoneDelegate parent, Zone zone, Exception error) {
if (error == null)
error = new ArgumentNullException(nameof(error));
_schedulePriorityAsyncCallback(() => {
_rethrow(error);
return null;
});
}
internal static void _rethrow(Exception ex) {
ExceptionDispatchInfo.Capture(ex).Throw();
}
internal static object _rootRun(Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f) {
if (Zone._current == zone) return f();
Zone old = Zone._enter(zone);
try {
return f();
}
finally {
Zone._leave(old);
}
}
internal static object _rootRunUnary(
Zone self, ZoneDelegate parent, Zone zone, ZoneUnaryCallback f, object arg) {
if (Zone._current == zone) return f(arg);
Zone old = Zone._enter(zone);
try {
return f(arg);
}
finally {
Zone._leave(old);
}
}
internal static object _rootRunBinary(Zone self, ZoneDelegate parent, Zone zone,
ZoneBinaryCallback f, object arg1, object arg2) {
if (Zone._current == zone) return f(arg1, arg2);
Zone old = Zone._enter(zone);
try {
return f(arg1, arg2);
}
finally {
Zone._leave(old);
}
}
internal static ZoneCallback _rootRegisterCallback(
Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f) {
return f;
}
internal static ZoneUnaryCallback _rootRegisterUnaryCallback(
Zone self, ZoneDelegate parent, Zone zone, ZoneUnaryCallback f) {
return f;
}
internal static ZoneBinaryCallback _rootRegisterBinaryCallback(
Zone self, ZoneDelegate parent, Zone zone, ZoneBinaryCallback f) {
return f;
}
internal static AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone, Exception error) =>
null;
internal static void _rootScheduleMicrotask(
Zone self, ZoneDelegate parent, Zone zone, ZoneCallback f) {
if (!ReferenceEquals(_rootZone, zone)) {
bool hasErrorHandler = !_rootZone.inSameErrorZone(zone);
if (hasErrorHandler) {
f = zone.bindCallbackGuarded(f);
}
else {
f = zone.bindCallback(f);
}
}
_scheduleAsyncCallback(f);
}
internal static Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone,
TimeSpan duration, ZoneCallback callback) {
if (!ReferenceEquals(_rootZone, zone)) {
callback = zone.bindCallback(callback);
}
return Timer._createTimer(duration, callback);
}
internal static Timer _rootCreatePeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
TimeSpan duration, ZoneUnaryCallback callback) {
if (!ReferenceEquals(_rootZone, zone)) {
callback = zone.bindUnaryCallback(callback);
}
return Timer._createPeriodicTimer(duration, callback);
}
internal static void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, string line) {
Debug.Log(line);
}
internal static Zone _rootFork(Zone self, ZoneDelegate parent, Zone zone,
ZoneSpecification specification, Hashtable zoneValues) {
if (specification == null) {
specification = new ZoneSpecification();
}
Hashtable valueMap;
if (zoneValues == null) {
valueMap = ((_Zone) zone)._map;
}
else {
valueMap = new Hashtable(zoneValues);
}
return new _CustomZone((_Zone) zone, specification, valueMap);
}
}
class _RootZone : _Zone {
internal override _RunNullaryZoneFunction _run =>
new _RunNullaryZoneFunction(async_._rootZone, async_._rootRun);
internal override _RunUnaryZoneFunction _runUnary =>
new _RunUnaryZoneFunction(async_._rootZone, async_._rootRunUnary);
internal override _RunBinaryZoneFunction _runBinary =>
new _RunBinaryZoneFunction(async_._rootZone, async_._rootRunBinary);
internal override _RegisterNullaryZoneFunction _registerCallback =>
new _RegisterNullaryZoneFunction(async_._rootZone, async_._rootRegisterCallback);
internal override _RegisterUnaryZoneFunction _registerUnaryCallback =>
new _RegisterUnaryZoneFunction(async_._rootZone, async_._rootRegisterUnaryCallback);
internal override _RegisterBinaryZoneFunction _registerBinaryCallback =>
new _RegisterBinaryZoneFunction(async_._rootZone, async_._rootRegisterBinaryCallback);
internal override _ZoneFunction<ErrorCallbackHandler> _errorCallback =>
new _ZoneFunction<ErrorCallbackHandler>(async_._rootZone, async_._rootErrorCallback);
internal override _ZoneFunction<ScheduleMicrotaskHandler> _scheduleMicrotask =>
new _ZoneFunction<ScheduleMicrotaskHandler>(async_._rootZone, async_._rootScheduleMicrotask);
internal override _ZoneFunction<CreateTimerHandler> _createTimer =>
new _ZoneFunction<CreateTimerHandler>(async_._rootZone, async_._rootCreateTimer);
internal override _ZoneFunction<CreatePeriodicTimerHandler> _createPeriodicTimer =>
new _ZoneFunction<CreatePeriodicTimerHandler>(async_._rootZone, async_._rootCreatePeriodicTimer);
internal override _ZoneFunction<PrintHandler> _print =>
new _ZoneFunction<PrintHandler>(async_._rootZone, async_._rootPrint);
internal override _ZoneFunction<ForkHandler> _fork =>
new _ZoneFunction<ForkHandler>(async_._rootZone, async_._rootFork);
internal override _ZoneFunction<HandleUncaughtErrorHandler> _handleUncaughtError =>
new _ZoneFunction<HandleUncaughtErrorHandler>(
async_._rootZone, async_._rootHandleUncaughtError);
internal override _Zone _parent => null;
internal override Hashtable _map => _rootMap;
static readonly Hashtable _rootMap = new Hashtable();
static ZoneDelegate _rootDelegate;
internal override ZoneDelegate _delegate {
get {
if (_rootDelegate != null) return _rootDelegate;
return _rootDelegate = new _ZoneDelegate(this);
}
}
public override Zone errorZone => this;
public override object runGuarded(ZoneCallback f) {
try {
if (ReferenceEquals(async_._rootZone, _current)) {
return f();
}
return async_._rootRun(null, null, this, f);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override object runUnaryGuarded(ZoneUnaryCallback f, object arg) {
try {
if (ReferenceEquals(async_._rootZone, _current)) {
return f(arg);
}
return async_._rootRunUnary(null, null, this, f, arg);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override object runBinaryGuarded(ZoneBinaryCallback f, object arg1, object arg2) {
try {
if (ReferenceEquals(async_._rootZone, _current)) {
return f(arg1, arg2);
}
return async_._rootRunBinary(null, null, this, f, arg1, arg2);
}
catch (Exception e) {
handleUncaughtError(e);
return null;
}
}
public override ZoneCallback bindCallback(ZoneCallback f) {
return () => run(f);
}
public override ZoneUnaryCallback bindUnaryCallback(ZoneUnaryCallback f) {
return (arg) => runUnary(f, arg);
}
public override ZoneBinaryCallback bindBinaryCallback(ZoneBinaryCallback f) {
return (arg1, arg2) => runBinary(f, arg1, arg2);
}
public override ZoneCallback bindCallbackGuarded(ZoneCallback f) {
return () => runGuarded(f);
}
public override ZoneUnaryCallback bindUnaryCallbackGuarded(ZoneUnaryCallback f) {
return (arg) => runUnaryGuarded(f, arg);
}
public override ZoneBinaryCallback bindBinaryCallbackGuarded(ZoneBinaryCallback f) {
return (arg1, arg2) => runBinaryGuarded(f, arg1, arg2);
}
public override object this[object key] => null;
public override void handleUncaughtError(Exception error) {
async_._rootHandleUncaughtError(null, null, this, error);
}
public override Zone fork(ZoneSpecification specification = null, Hashtable zoneValues = null) {
return async_._rootFork(null, null, this, specification, zoneValues);
}
public override object run(ZoneCallback f) {
if (ReferenceEquals(_current, async_._rootZone)) return f();
return async_._rootRun(null, null, this, f);
}
public override object runUnary(ZoneUnaryCallback f, object arg) {
if (ReferenceEquals(_current, async_._rootZone)) return f(arg);
return async_._rootRunUnary(null, null, this, f, arg);
}
public override object runBinary(ZoneBinaryCallback f, object arg1, object arg2) {
if (ReferenceEquals(_current, async_._rootZone)) return f(arg1, arg2);
return async_._rootRunBinary(null, null, this, f, arg1, arg2);
}
public override ZoneCallback registerCallback(ZoneCallback f) => f;
public override ZoneUnaryCallback registerUnaryCallback(ZoneUnaryCallback f) => f;
public override ZoneBinaryCallback registerBinaryCallback(ZoneBinaryCallback f) => f;
public override AsyncError errorCallback(Exception error) => null;
public override void scheduleMicrotask(ZoneCallback f) {
async_._rootScheduleMicrotask(null, null, this, f);
}
public override Timer createTimer(TimeSpan duration, ZoneCallback f) {
return Timer._createTimer(duration, f);
}
public override Timer createPeriodicTimer(TimeSpan duration, ZoneUnaryCallback f) {
return Timer._createPeriodicTimer(duration, f);
}
public override void print(string line) {
Debug.Log(line);
}
}
public static partial class async_ {
internal static readonly _Zone _rootZone = new _RootZone();
public static R runZoned<R>(Func<R> body,
Hashtable zoneValues = null, ZoneSpecification zoneSpecification = null) {
if (body == null)
throw new ArgumentNullException(nameof(body));
return _runZoned(body, zoneValues, zoneSpecification);
}
public static R runZonedGuarded<R>(Func<R> body, Action<Exception> onError,
Hashtable zoneValues = null, ZoneSpecification zoneSpecification = null) {
if (body == null)
throw new ArgumentNullException(nameof(body));
if (onError == null)
throw new ArgumentNullException(nameof(onError));
HandleUncaughtErrorHandler errorHandler =
(Zone self, ZoneDelegate parent, Zone zone, Exception error) => {
try {
self.parent.runUnary((e) => {
onError((Exception) e);
return null;
}, error);
}
catch (Exception e) {
parent.handleUncaughtError(zone, e);
}
};
if (zoneSpecification == null) {
zoneSpecification =
new ZoneSpecification(handleUncaughtError: errorHandler);
}
else {
zoneSpecification = ZoneSpecification.from(zoneSpecification,
handleUncaughtError: errorHandler);
}
try {
return _runZoned(body, zoneValues, zoneSpecification);
}
catch (Exception error) {
onError(error);
}
return default;
}
internal static R _runZoned<R>(Func<R> body, Hashtable zoneValues, ZoneSpecification specification) =>
(R) Zone.current
.fork(specification: specification, zoneValues: zoneValues)
.run(() => body());
}
}