private static void CallAsyncResult(Task task, IMessageSource source, UInt64 session)
{
switch (task.Status)
{
case TaskStatus.Canceled:
{
source.Respond(new ExceptionMessage(session, new TaskCanceledException()));
}
break;
case TaskStatus.Faulted:
{
source.Respond(new ExceptionMessage(session, task.Exception.InnerException));
}
break;
case TaskStatus.RanToCompletion:
{
Type taskType = task.GetType();
if (taskType.IsGenericType && TypeFormatter.CanSerialize(taskType.GetGenericArguments()[0]))
{
object result = taskType.GetProperty("Result", BindingFlags.Public | BindingFlags.Instance).GetValue(task, null);
source.Respond(new ResultMessage(session, result));
}
else
{
source.Respond(new ResultMessage(session, null));
}
}
break;
}
}
/// <summary>
/// Executes appropriate handler based on actual type of the <paramref name="view"/> with returning a result.
/// </summary>
/// <typeparam name="T">The type of the result.</typeparam>
/// <param name="view">The view that is represented by the <see cref="UIViewController"/> or <see cref="UINavigationController"/>.</param>
/// <param name="viewControllerHandler">The handler to execute when the <paramref name="view"/> is <see cref="UIViewController"/>.</param>
/// <param name="navigationControllerHandler">
/// The handler to execute when the <paramref name="view"/> is <see cref="UINavigationController"/>. Can be <see langword="null"/>.
/// <para>If the <paramref name="navigationControllerHandler"/> is <see langword="null"/> then the <paramref name="viewControllerHandler"/> will be used as a handler.</para>
/// </param>
/// <returns>A result returned by appropriate handler.</returns>
/// <exception cref="ArgumentNullException"><paramref name="view" /> or <paramref name="viewControllerHandler" /> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">
/// The <paramref name="view" /> is derived from a class other than the <see cref="UIViewController"/>.
/// </exception>
public static T As <T>(
this IView <ILifecycleViewModel> view,
Func <UIViewController, T> viewControllerHandler,
Func <UINavigationController, T>?navigationControllerHandler = null)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (viewControllerHandler == null)
{
throw new ArgumentNullException(nameof(viewControllerHandler));
}
T result;
if (view is UINavigationController navigationController)
{
result = (navigationControllerHandler ?? viewControllerHandler)(navigationController);
}
else if (view is UIViewController viewController)
{
result = viewControllerHandler(viewController);
}
else
{
throw new ArgumentException($"Only views derived from the '{TypeFormatter.FormatName<UIViewController>()}' type are supported.", nameof(view));
}
return(result);
}
private static void Call(IMessageSource source, IMessage message, Func <object[], object> target, bool extend)
{
object[] args; message.TryGetInvocationArgs(out args);
if (extend)
{
args = args.Insert(0, source);
}
try
{
object result = target(args);
if (result != null && !TypeFormatter.CanSerialize(result.GetType()))
{
result = null;
}
source.Respond(new ResultMessage(message, result));
}
catch (Exception er)
{
try
{
source.Respond(new ExceptionMessage(message, er));
}
catch (Exception fatal)
{
Application.Error(fatal);
}
}
}
internal static TView Get <TView, TViewModel>(TViewModel viewModel)
where TView : class, IView <TViewModel>
where TViewModel : class, ILifecycleViewModel
{
TView?view = null;
for (var i = ViewsWeakReferences.Count - 1; i > -1; i--)
{
var viewWeakReference = ViewsWeakReferences[i];
if (viewWeakReference.TryGetTarget(out var cachedView))
{
if (ReferenceEquals(cachedView.ViewModel, viewModel))
{
view = (TView)cachedView;
break;
}
}
else
{
ViewsWeakReferences.Remove(viewWeakReference);
}
}
if (view == null)
{
throw new InvalidOperationException(
$"The view instance is missing for the provided '{TypeFormatter.FormatName(viewModel.GetType())}' view model one.");
}
return(view);
}
static ObjectFormatter()
{
new StringFormatter().Register();
new Int64Formatter().Register();
new Int32Formatter().Register();
new Int16Formatter().Register();
new ByteFormatter().Register();
new BooleanFormatter().Register();
new CharFormatter().Register();
new DateTimeFormatter().Register();
new PairFormatter().Register();
new TripletFormatter().Register();
new ArrayListFormatter().Register();
new HashtableFormatter().Register();
new ObjectArrayFormatter().Register();
new UnitFormatter().Register();
new FontUnitFormatter().Register();
new ColorFormatter().Register();
enumFormatter = new EnumFormatter();
enumFormatter.Register();
typeFormatter = new TypeFormatter();
typeFormatter.Register();
singleRankArrayFormatter = new SingleRankArrayFormatter();
singleRankArrayFormatter.Register();
typeConverterFormatter = new TypeConverterFormatter();
typeConverterFormatter.Register();
binaryObjectFormatter = new BinaryObjectFormatter();
binaryObjectFormatter.Register();
}
public TypeCollectionTester(ExtractedTypeCollection typeCollection)
{
_typeCollection = typeCollection;
// TODO any way to define this? Or maybe an option when getting type name
_typeFormatter = new TypeScriptTypeFormatter(_typeCollection, new FakeTypePrefixer());
}
public MvcActionTextTemplate(MvcAction action, ScriptExtensionsFactory extensionsFactory, FetchFunctionDescriptor fetchFunc, TypeFormatter formatter)
{
_action = action;
_formatter = formatter;
_fetchFunc = fetchFunc;
_bodyExtensions = extensionsFactory.CreateForActionFunctionBody(action);
}
/// <summary>
/// Executes appropriate handler based on actual type of the <paramref name="view"/>.
/// </summary>
/// <param name="view">The view that is represented by an activity or fragment.</param>
/// <param name="activityHandler">The handler to execute if <paramref name="view"/> is <see cref="Android.Support.V4.App.FragmentActivity"/>.</param>
/// <param name="fragmentHandler">The handler to execute if <paramref name="view"/> is <see cref="Android.Support.V4.App.Fragment"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="view" /> or <paramref name="activityHandler" /> or <paramref name="fragmentHandler" /> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">
/// The <paramref name="view" /> is derived from a class other than the <see cref="Android.Support.V4.App.FragmentActivity"/> or <see cref="Android.Support.V4.App.Fragment"/>.
/// </exception>
public static void As(
this IView <ILifecycleViewModel> view,
Action <FragmentActivity> activityHandler,
Action <Fragment> fragmentHandler)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (activityHandler == null)
{
throw new ArgumentNullException(nameof(activityHandler));
}
if (fragmentHandler == null)
{
throw new ArgumentNullException(nameof(fragmentHandler));
}
if (view is FragmentActivity activity)
{
activityHandler(activity);
}
else if (view is Fragment fragment)
{
fragmentHandler(fragment);
}
else
{
throw new ArgumentException(
$"Only views derived from the '{TypeFormatter.FormatName<FragmentActivity>()}' or " +
$"'{TypeFormatter.FormatName<Fragment>()}' are supported.", nameof(view));
}
}
/// <summary>
/// Performs forward navigation from the <paramref name="sourceView"/> to the target one with the provided lifecycle-aware view model <paramref name="parameters"/>
/// and handling a lifecycle-aware view model result when it finished.
/// </summary>
/// <typeparam name="TTargetView">The type of the target view.</typeparam>
/// <typeparam name="TParameters">The type of the target view model parameters.</typeparam>
/// <typeparam name="TResult">The type of the target view model result.</typeparam>
/// <param name="sourceView">The source navigation view from which navigation is performed from.</param>
/// <param name="parameters">The target view model parameters. Can be <see langword="null"/>.</param>
/// <param name="navigationStrategy">
/// The strategy used for performing navigation. Can be <see langword="null"/>.
/// <para>The default is <see cref="ForwardNavigationStrategy.StartActivityForResult(Bundle?)"/>.</para>
/// </param>
/// <exception cref="ArgumentNullException"><paramref name="sourceView"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">
/// The <paramref name="sourceView" /> is derived from a class other than the <see cref="FragmentActivity"/> or <see cref="Fragment"/>.
/// </exception>
/// <exception cref="InvalidOperationException">
/// <see cref="NavigationViewExtensions.GetActivity(INavigationView{ILifecycleViewModel})"/> returned <see langword="null"/> value for the provided <paramref name="sourceView"/>.
/// </exception>
public void NavigateForResult <TTargetView, TParameters, TResult>(
INavigationView <ILifecycleViewModelWithResultHandler> sourceView,
TParameters?parameters,
ForwardNavigationDelegate?navigationStrategy = null)
where TTargetView : FragmentActivity, INavigationView <ILifecycleViewModelWithParameters <TParameters> >, INavigationView <ILifecycleViewModelWithResult <TResult> >
where TParameters : Parameters
where TResult : Result
{
if (sourceView == null)
{
throw new ArgumentNullException(nameof(sourceView));
}
var context = sourceView.GetActivity();
if (context == null)
{
throw new InvalidOperationException(
$"'{TypeFormatter.FormatName(sourceView.GetType())}.{nameof(NavigationViewExtensions.GetActivity)}' returned 'null' value.");
}
var targetViewIntent = new Intent(context, typeof(TTargetView));
targetViewIntent.PutParameters(parameters);
var requestCode = sourceView.RequestCode.GetFor <DefaultResultMapper <TResult> >();
(navigationStrategy ?? NavigationStrategy.Forward.StartActivityForResult()).Invoke(sourceView, targetViewIntent, requestCode);
}
public object ConvertBack(object value, Type targetType)
{
if (targetType == null)
{
throw new ArgumentNullException(nameof(targetType));
}
var valueConverter = ValueConverterProvider.Get <TValueConverter>();
var convertedValue = BindingValue.UnsetValue;
if (TryGetParameter(out var parameter))
{
try
{
convertedValue = valueConverter.ConvertBack(value, targetType, parameter, _converterCulture);
}
catch (Exception ex)
{
Log($"An \"{LogFormatter.FormatException(ex)}\" exception occurred while converting \"{value ?? "null"}\" value from the target item to the source one " +
$"using \"{TypeFormatter.FormatName<TValueConverter>()}\" value converter.");
}
}
return(convertedValue);
}
/// <summary>
/// Executes appropriate handler based on actual type of the <paramref name="view"/>.
/// </summary>
/// <param name="view">The view that is represented by a navigation or view controller.</param>
/// <param name="navigationControllerHandler">The handler to execute if <paramref name="view"/> is <see cref="UINavigationController"/>.</param>
/// <param name="viewControllerHandler">The handler to execute if <paramref name="view"/> is <see cref="UIViewController"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="view" /> or <paramref name="navigationControllerHandler" /> or <paramref name="viewControllerHandler" /> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">
/// The <paramref name="view" /> is derived from a class other than the <see cref="UINavigationController"/> or <see cref="UIViewController"/>.
/// </exception>
public static void As(
this IView <ILifecycleViewModel> view,
Action <UINavigationController> navigationControllerHandler,
Action <UIViewController> viewControllerHandler)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (navigationControllerHandler == null)
{
throw new ArgumentNullException(nameof(navigationControllerHandler));
}
if (viewControllerHandler == null)
{
throw new ArgumentNullException(nameof(viewControllerHandler));
}
if (view is UINavigationController navigationController)
{
navigationControllerHandler(navigationController);
}
else if (view is UIViewController viewController)
{
viewControllerHandler(viewController);
}
else
{
throw new ArgumentException(
$"Only views derived from the '{TypeFormatter.FormatName<UINavigationController>()}' or " +
$"'{TypeFormatter.FormatName<UIViewController>()}' are supported.", nameof(view));
}
}
private void ProcessStats(object state)
{
var currentTrace = Interlocked.Exchange(ref grainTrace, new ConcurrentDictionary <string, SiloGrainTraceEntry>());
if (currentTrace.Count > 0)
{
if (siloAddress == null)
{
siloAddress = localSiloDetails.SiloAddress.ToParsableString();
}
var items = currentTrace.Values.ToArray();
foreach (var item in items)
{
item.Grain = TypeFormatter.Parse(item.Grain);
}
try
{
dashboardGrain = dashboardGrain ?? grainFactory.GetGrain <IDashboardGrain>(0);
dashboardGrain.SubmitTracing(siloAddress, items.AsImmutable()).Ignore();
}
catch (Exception ex)
{
logger.LogWarning(100001, ex, "Exception thrown sending tracing to dashboard grain");
}
}
}
public void TestSimpleType()
{
var example = "System.String";
var name = TypeFormatter.Parse(example);
Assert.Equal("System.String", name);
}
public void SetUp()
{
sw = new StringWriter();
var tf = new TextFormatter(sw) { Indentation = 0 };
tyfo = new TypeFormatter(tf, false);
tf = new TextFormatter(sw) { Indentation = 0 };
tyreffo = new TypeReferenceFormatter(tf, false);
}
public void TestGenericGrainWithFsType()
{
var example = ".Program.Progress";
var name = TypeFormatter.Parse(example);
Assert.Equal(".Program.Progress", name);
}
public void ShouldFormatNullableForStructureTypes(Type type, string expectedRender)
{
// Act
var render = TypeFormatter.Format(type);
// Assert
Assert.Equal(expectedRender, render);
}
public void TestGenericGrainWithMultipleTs()
{
var example = typeof(ITestGenericGrain <string, int>).FullName;
var name = TypeFormatter.Parse(example);
Assert.Equal("TestGrains.ITestGenericGrain<String, Int32>", name);
}
public void ShouldFormatComplexGenericType(Type type, string expectedRender)
{
// Act
var render = TypeFormatter.Format(type);
// Assert
Assert.Equal(expectedRender, render);
}
public void ShouldFormatKeywordForSystemTypes(Type type, string expectedRender)
{
// Act
var render = TypeFormatter.Format(type);
// Assert
Assert.Equal(expectedRender, render);
}
public void TestCustomType()
{
var example = "ExecuteAsync(CreateApp)";
var name = TypeFormatter.Parse(example);
Assert.Equal("ExecuteAsync(CreateApp)", name);
}
public void TestFriendlyNameForStrings()
{
var example = "TestGrains.GenericGrain`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]";
var name = TypeFormatter.Parse(example);
Assert.Equal("TestGrains.GenericGrain<String>", name);
}
public MvcControllerTextTemplate(ControllerContext context, ScriptExtensionsFactory extensionsFactory)
{
_context = context;
_scriptExtensions = extensionsFactory;
_imports = ImportManager.FromControllerContext(context);
_formatter = new TypeScriptTypeFormatter(context.TypeCollection, new ModuleTypePrefixResolver(_imports));
_postScriptExtensions = _scriptExtensions.CreatePostControllerScript(context);
}
/// <summary>
/// Gets the script for the extracted types
/// </summary>
/// <param name="context">The context for writing the script</param>
/// <returns>The script text</returns>
public string GetText(TypeWriteContext context)
{
_context = context;
_imports = ImportManager.FromTypes(_context.IncludedTypes, _context.OutputPath);
_formatter = new TypeScriptTypeFormatter(context.TypeCollection, new ModuleTypePrefixResolver(_imports)); // Add no prefix to the types
return(TransformText());
}
public override string ToString()
{
StringWriter sw = new StringWriter();
TextFormatter fmt = new TextFormatter(sw);
CodeFormatter cf = new CodeFormatter(fmt);
TypeFormatter tf = new TypeFormatter(fmt, false);
Signature.Emit(Name, ProcedureSignature.EmitFlags.ArgumentKind, fmt, cf, tf);
return sw.ToString();
}
public override string ToString()
{
StringWriter sw = new StringWriter();
TextFormatter fmt = new TextFormatter(sw);
CodeFormatter cf = new CodeFormatter(fmt);
TypeFormatter tf = new TypeFormatter(fmt);
Signature.Emit(Name, FunctionType.EmitFlags.ArgumentKind, fmt, cf, tf);
return(sw.ToString());
}
public void TestGenericWithMultipleTs()
{
var example = typeof(IGenericGrain <Tuple <string, int> >).FullName;
Console.WriteLine(example);
var name = TypeFormatter.Parse(example);
Assert.Equal("TestGrains.IGenericGrain<Tuple<String, Int32>>", name);
}
public string ToString(string name, EmitFlags flags = EmitFlags.ArgumentKind)
{
StringWriter sw = new StringWriter();
TextFormatter f = new TextFormatter(sw);
CodeFormatter cf = new CodeFormatter(f);
TypeFormatter tf = new TypeFormatter(f);
Emit(name, flags, f, cf, tf);
return(sw.ToString());
}
public override string ToString()
{
StringWriter w = new StringWriter();
TextFormatter f = new TextFormatter(w);
CodeFormatter cf = new CodeFormatter(f);
TypeFormatter tf = new TypeFormatter(f, false);
Emit("()", EmitFlags.ArgumentKind | EmitFlags.LowLevelInfo, f, cf, tf);
return(w.ToString());
}
public void ShouldFormatNameForStandardTypes()
{
// Arrange
var type = typeof(IList);
// Act
var render = TypeFormatter.Format(type);
// Assert
Assert.Equal("System.Collections.IList", render);
}
void ICommand.Execute(object parameter)
{
if (parameter != null)
{
throw new ArgumentException(
$"\"{_name.SelfOrDefaultIfNullOrWhiteSpace(TypeFormatter.FormatName(GetType()))}\" command expects \"null\" value.",
nameof(parameter));
}
Execute();
}
public void TestName()
{
var expected = typeof(Subject).GetTypeInfo();
var @namespace = NamespaceFormatter.Default.Get(expected);
var aliases = new Names(new TypedTable <string>(DefaultNames.Default));
var formatter = new TypeFormatter(aliases);
var partitions = new AssemblyTypePartitions(PartitionedTypeSpecification.Default, formatter);
var type = new PartitionedTypeCandidates(TypeLoader.Default, partitions).Get(new Identity(formatter.Get(expected), @namespace)).Only();
Assert.Equal(expected, type);
}
public void ShouldFormatNestedGenericType()
{
// Arrange
var type = typeof(NestedGenericType <int>);
var expectedRender = $"{typeof(TypeFormatterTests).FullName}.NestedGenericType<int>";
// Act
var render = TypeFormatter.Format(type);
// Assert
Assert.Equal(expectedRender, render);
}
public void Emit(string fnName, EmitFlags f, Formatter fmt, CodeFormatter w, TypeFormatter t)
{
bool emitStorage = (f & EmitFlags.ArgumentKind) == EmitFlags.ArgumentKind;
if (emitStorage)
{
if (ReturnValue != null)
{
w.WriteFormalArgumentType(ReturnValue, emitStorage);
fmt.Write(" ");
}
else
{
fmt.Write("void ");
}
fmt.Write("{0}(", fnName);
}
else
{
if (ReturnValue == null)
fmt.Write("void {0}", fnName);
else
{
t.Write(ReturnValue.DataType, fnName); //$TODO: won't work with fn's that return pointers to functions or arrays.
}
fmt.Write("(");
}
var sep = "";
if (Parameters != null)
{
for (int i = 0; i < Parameters.Length; ++i)
{
fmt.Write(sep);
sep = ", ";
w.WriteFormalArgument(Parameters[i], emitStorage, t);
}
}
fmt.Write(")");
if ((f & EmitFlags.LowLevelInfo) == EmitFlags.LowLevelInfo)
{
fmt.WriteLine();
fmt.Write("// stackDelta: {0}; fpuStackDelta: {1}; fpuMaxParam: {2}", StackDelta, FpuStackDelta, FpuStackArgumentMax);
fmt.WriteLine();
}
}
public override string ToString()
{
StringWriter w = new StringWriter();
TextFormatter f = new TextFormatter(w);
CodeFormatter cf = new CodeFormatter(f);
TypeFormatter tf = new TypeFormatter(f, false);
Emit("()", EmitFlags.ArgumentKind | EmitFlags.LowLevelInfo, f, cf, tf);
return w.ToString();
}
public string ToString(string name)
{
StringWriter sw = new StringWriter();
TextFormatter f = new TextFormatter(sw);
CodeFormatter cf = new CodeFormatter(f);
TypeFormatter tf = new TypeFormatter(f, false);
Emit(name, EmitFlags.ArgumentKind, f, cf, tf);
return sw.ToString();
}
static ObjectFormatter ()
{
new StringFormatter ().Register ();
new Int64Formatter ().Register ();
new Int32Formatter ().Register ();
new Int16Formatter ().Register ();
new ByteFormatter ().Register ();
new BooleanFormatter ().Register ();
new CharFormatter ().Register ();
new DateTimeFormatter ().Register ();
new PairFormatter ().Register ();
new TripletFormatter ().Register ();
new ArrayListFormatter ().Register ();
new HashtableFormatter ().Register ();
new ObjectArrayFormatter ().Register ();
new UnitFormatter ().Register ();
new FontUnitFormatter ().Register ();
new IndexedStringFormatter ().Register ();
new ColorFormatter ().Register ();
enumFormatter = new EnumFormatter ();
enumFormatter.Register ();
typeFormatter = new TypeFormatter ();
typeFormatter.Register ();
singleRankArrayFormatter = new SingleRankArrayFormatter ();
singleRankArrayFormatter.Register ();
typeConverterFormatter = new TypeConverterFormatter ();
typeConverterFormatter.Register ();
binaryObjectFormatter = new BinaryObjectFormatter ();
binaryObjectFormatter.Register ();
}
public void SetUp()
{
sw = new StringWriter();
tyfo = new TypeFormatter(new TextFormatter(sw), false);
tyreffo = new TypeReferenceFormatter(new TextFormatter(sw), false);
}
public void WriteFormalArgument(Identifier arg, bool writeStorage, TypeFormatter t)
{
if (writeStorage)
{
WriteFormalArgumentType(arg, writeStorage);
writer.Write(" ");
writer.Write(arg.Name);
}
else
{
if (arg.Storage is OutArgumentStorage)
{
t.Write(new ReferenceTo(arg.DataType), arg.Name);
}
else
{
t.Write(arg.DataType, arg.Name);
}
}
}
public void WriteDecompiledTypes(Program program, TextWriter w)
{
WriteHeaderComment(Path.GetFileName(program.TypesFilename), program, w);
w.WriteLine("/*"); program.TypeStore.Write(w); w.WriteLine("*/");
var tf = new TextFormatter(w)
{
Indentation = 0,
};
TypeFormatter fmt = new TypeFormatter(tf, false);
foreach (EquivalenceClass eq in program.TypeStore.UsedEquivalenceClasses)
{
if (eq.DataType != null)
{
w.Write("typedef ");
fmt.Write(eq.DataType, eq.Name);
w.WriteLine(";");
w.WriteLine();
}
}
}
public void WriteFormalArgument(Identifier arg, bool writeStorage, TypeFormatter t)
{
if (writeStorage)
{
WriteFormalArgumentType(arg, writeStorage);
writer.Write(" ");
writer.Write(arg.Name);
}
else
{
t.Write(arg.DataType, arg.Name);
}
}
public void VisitDeclaration(AbsynDeclaration decl)
{
writer.Indent();
if (decl.Identifier.DataType != null)
{
TypeFormatter tf = new TypeFormatter(writer, true);
tf.Write(decl.Identifier.DataType, decl.Identifier.Name);
}
else
{
writer.Write("?unknown?");
writer.Write(" ");
decl.Identifier.Accept(this);
}
if (decl.Expression != null)
{
writer.Write(" = ");
decl.Expression.Accept(this);
}
writer.Terminate(";");
}
public void VisitDeclaration(Declaration decl)
{
writer.Indent();
Debug.Assert(decl.Identifier.DataType != null, "The DataType property can't ever be null");
TypeFormatter tf = new TypeFormatter(writer, true);
tf.Write(decl.Identifier.DataType, decl.Identifier.Name);
if (decl.Expression != null)
{
writer.Write(" = ");
decl.Expression.Accept(this);
}
writer.Terminate();
}
private void SetTextView(DataType dt)
{
var tsf = new TextSpanFormatter() { Indentation = 0 };
var fmt = new TypeFormatter(tsf, false);
tsf.UseTabs = false;
fmt.Write(dt, "");
this.TextView.Model = tsf.GetModel();
}
