// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Represents a stack of ITypeDataProvider/IStackedTypeDataProvider that is used to get TypeData for a given type.
|
/// The providers on this stack are called in order until a provider returuns a
|
/// </summary>
|
public class TypeDataProviderStack
|
{
|
object[] providers;
|
int offset = 0;
|
|
internal TypeDataProviderStack()
|
{
|
offset = 0;
|
providers = GetProviders();
|
}
|
|
private TypeDataProviderStack(object[] providers, int providerOffset)
|
{
|
this.providers = providers;
|
this.offset = providerOffset;
|
}
|
|
/// <summary> Gets the type data from an object. </summary>
|
/// <param name="obj">The object to get type information for.</param>
|
/// <returns>A representation of the type of the specified object or null if no providers can handle the specified type of object.</returns>
|
public ITypeData GetTypeData(object obj)
|
{
|
if (obj == null)
|
return null;
|
while (offset < providers.Length)
|
{
|
var provider = providers[offset];
|
offset++;
|
try
|
{
|
if (provider is IStackedTypeDataProvider sp)
|
{
|
var newStack = new TypeDataProviderStack(providers, offset);
|
if (sp.GetTypeData(obj, newStack) is ITypeData found)
|
return found;
|
}
|
else if (provider is ITypeDataProvider p)
|
{
|
if (p.GetTypeData(obj) is ITypeData found)
|
return found;
|
}
|
}
|
catch (Exception error)
|
{
|
logProviderError(provider, error);
|
}
|
}
|
|
if (!failedGetWarnHit)
|
{
|
// Todo: Change this method to never return null and throw in this case. Just added this warning for now, to see if this ever happens
|
log.Warning("Could not get TypeData for {0}", obj.GetType().FullName);
|
failedGetWarnHit = true;
|
}
|
return null;
|
}
|
|
static bool failedGetWarnHit = false;
|
static TraceSource log = Log.CreateSource("TypeDataProvider");
|
|
static void logProviderError(object provider, Exception error)
|
{
|
var log = Log.CreateSource(provider.GetType().Name);
|
log.Error("Unhandled error occured in type resolution: {0}", error.Message);
|
log.Debug(error);
|
}
|
|
/// <summary> Gets the type data from an identifier. </summary>
|
/// <param name="identifier">The identifier to get type information for.</param>
|
/// <returns>A representation of the type specified by identifier or null if no providers can handle the specified identifier.</returns>
|
public ITypeData GetTypeData(string identifier)
|
{
|
if (identifier == null) return null;
|
while (offset < providers.Length)
|
{
|
var provider = providers[offset];
|
offset++;
|
try
|
{
|
if (provider is IStackedTypeDataProvider sp)
|
{
|
var newStack = new TypeDataProviderStack(providers, offset);
|
if (sp.GetTypeData(identifier, newStack) is ITypeData found)
|
return found;
|
}
|
else if (provider is ITypeDataProvider p)
|
{
|
if (p.GetTypeData(identifier) is ITypeData found)
|
return found;
|
}
|
}
|
catch (Exception error)
|
{
|
logProviderError(provider, error);
|
}
|
}
|
|
return null;
|
}
|
|
static object providersCacheLockObj = new object();
|
static object[] providersCache = new object[0];
|
static readonly HashSet<ITypeData> badProviders = new HashSet<ITypeData>();
|
static int lastCount = 0;
|
static object[] GetProviders()
|
{
|
var providers1 = TypeData.FromType(typeof(IStackedTypeDataProvider)).DerivedTypes;
|
var providers2 = TypeData.FromType(typeof(ITypeDataProvider)).DerivedTypes;
|
|
int l1 = providers1.Count();
|
int l2 = providers2.Count();
|
|
if (lastCount == l1 + l2) return providersCache;
|
|
lock (providersCacheLockObj)
|
{
|
if (lastCount == l1 + l2) return providersCache;
|
Dictionary<object, double> priorities = new Dictionary<object, double>();
|
foreach (var providerType in providers1.Concat(providers2).Distinct())
|
{
|
if (providerType.CanCreateInstance == false) continue;
|
|
try
|
{
|
var provider = providerType.CreateInstance();
|
if (provider == null)
|
{
|
throw new Exception(
|
$"Failed to instantiate TypeDataProvider of type '{providerType.Name}'.");
|
}
|
|
double priority;
|
|
if (provider is IStackedTypeDataProvider p)
|
priority = p.Priority;
|
else if (provider is ITypeDataProvider p2)
|
priority = p2.Priority;
|
else
|
{
|
lock (badProviders)
|
{
|
if (badProviders.Contains(providerType))
|
continue; // error was printed first time, so just continue.
|
}
|
|
throw new InvalidOperationException("Unreachable code path executed.");
|
}
|
priorities.Add(provider, priority);
|
}
|
catch (Exception e)
|
{
|
while (e is TargetInvocationException te)
|
e = te.InnerException;
|
|
bool isNewError;
|
lock (badProviders)
|
isNewError = badProviders.Add(providerType);
|
if (isNewError)
|
{
|
log.Error("Unable to use TypeDataProvider of type '{0}' due to errors.", providerType.Name);
|
log.Debug("The error was '{0}'", e.Message);
|
log.Debug(e);
|
}
|
}
|
}
|
|
providersCache = priorities.Keys.OrderByDescending(x => priorities[x]).ToArray();
|
lastCount = l1 + l2;
|
}
|
return providersCache;
|
}
|
}
|
}
|
