private object CreateFromString(Type targetType,string name)
{
object instance = null;
if (FrameworkElement != null)
{
instance = FrameworkElement.FindResource(name);
if (instance != null && targetType.IsAssignableFrom(instance.GetType())) return instance;
instance = null;
}
if(Contains(name))
{
instance = this[name];
if (instance != null && targetType.IsAssignableFrom(instance.GetType())) return instance;
instance = null;
}
if (!RequireExactMatch)
{
foreach (string key in Keys)
{
if (key.Contains(name))
{
instance = this[key];
if (instance != null && targetType.IsAssignableFrom(instance.GetType())) return instance;
}
}
}
return null;
}
/// <summary>
/// Copies the specified source.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="type">The type the source and target should be interpreded as.</param>
/// <param name="progressDelegate">The progress delegate.</param>
public static void Copy(ICopy source, ICopy target, Type type, CopyToProgress progressDelegate)
{
if (!(type.IsAssignableFrom(source.GetType()) && type.IsAssignableFrom(target.GetType())))
throw new ArgumentException("Source and Target must implement " + type.ToString());
foreach (PropertyInfo info in type.GetProperties())
{
if (type.GetProperty(info.Name).IsDefined(typeof(IgnoreCopyAttribute), true) ||
source.GetType().GetProperty(info.Name).IsDefined(typeof(IgnoreCopyAttribute), true) ||
target.GetType().GetProperty(info.Name).IsDefined(typeof(IgnoreCopyAttribute), true))
continue;
if (typeof(ICopy).IsAssignableFrom(info.PropertyType))
{
ICopy copyObject = (info.GetValue(source, null) as ICopy);
if (copyObject != null)
copyObject.CopyTo(info.GetValue(target, null) as ICopy, progressDelegate);
}
if (info.IsDefined(typeof(ValueCopyAttribute), true))
{
object value = info.GetValue(source, null);
if (value != null)
info.SetValue(target, value, null);
}
}
}
public override IEnumerable<TestCaseParameter> CreateInstances(Type targetType)
{
System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions();
foreach (MethodInfo method in ReflectionHelper.GetMethods(this.FactoryType, typeof(FactoryAttribute)))
{
if (method.GetParameters().Length > 0)
continue;
FactoryAttribute factoryAttribute = ReflectionHelper.GetAttribute<FactoryAttribute>(method);
// the method returns the type or a enumerable collection
if (targetType.IsAssignableFrom(method.ReturnType))
yield return CreateSingleInstance(method);
else if (
targetType.IsAssignableFrom(typeof(IEnumerable<>).MakeGenericType(targetType))
|| (
targetType.IsAssignableFrom(typeof(IEnumerable))
&& targetType.IsAssignableFrom(factoryAttribute.FactoredType)
)
)
{
foreach (TestCaseParameter parameter in CreateMultipleInstances(method))
yield return parameter;
}
}
}
public static ValueViewModel GetAppropriateViewModel(Type PropertyType, Object ValueObject)
{
if (PropertyType.IsAssignableFrom(typeof (int))) return new IntValueViewModel(ValueObject);
if (PropertyType.IsAssignableFrom(typeof (bool))) return new BooleanValueViewModel(ValueObject);
if (PropertyType.IsAssignableFrom(typeof (string))) return new StringValueViewModel(ValueObject);
throw new ApplicationException("Не поддерживаемый для редактирования тип свойства!");
}
public Type GetActualType(Type type, IAdviceRequester adviceRequester)
{
Type result = null;
if (type != null)
{
if (type != typeof(string))
{
if (!typeof(IDictionary).IsAssignableFrom(type) &&
(!type.IsGenericType || type.GetGenericArguments().Length != 2 || !typeof(IDictionary<,>).MakeGenericType(type.GetGenericArguments()).IsAssignableFrom(type)))
{
if (type.IsClass && typeof(IEnumerable).IsAssignableFrom(type))
result = type;
else
{
if (type.IsInterface && type.IsAssignableFrom(typeof(List<object>)))
result = typeof(List<object>);
else
{
if (type.IsGenericType && type.GetGenericArguments().Length == 1 && type.IsAssignableFrom(typeof(List<>).MakeGenericType(type.GetGenericArguments())))
result = typeof(List<>).MakeGenericType(type.GetGenericArguments());
}
}
}
}
}
if (_log.IsDebugEnabled)
_log.Debug("Converted '" + type + "' to '" + result + "'.");
return result;
}
static object InternalConvert(object arg, Type source, Type target, bool isAddress)
{
if (target == source)
return arg;
if (target.IsValueType)
{
if (source.IsValueType)
{
if (!CanConvert (Type.GetTypeCode (target)))
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.NoConversionPossibleTo, DataContract.GetClrTypeFullName(target))));
else
return target;
}
else if (source.IsAssignableFrom(target))
return arg;
else
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.IsNotAssignableFrom, DataContract.GetClrTypeFullName(target), DataContract.GetClrTypeFullName(source))));
}
else if (target.IsAssignableFrom(source))
return arg;
else if (source.IsAssignableFrom(target))
return arg;
else if (target.IsInterface || source.IsInterface)
return arg;
else
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.IsNotAssignableFrom, DataContract.GetClrTypeFullName(target), DataContract.GetClrTypeFullName(source))));
}
public ViewModelConfig CreateViewModelConfig(Type type)
{
if (!type.IsBaseObject() && !type.IsDefined(typeof(ComplexTypeAttribute))) return null;
string serviceName = "";
if (type.IsBaseObject())
{
if (type.IsAssignableFrom(typeof(HCategory)))
serviceName = typeof(IBaseCategoryService<>).GetTypeName();
else if (type.IsAssignableFrom(typeof(ICategorizedItem)))
serviceName = typeof(IBaseCategorizedItemService<>).GetTypeName();
else
serviceName = typeof(IBaseObjectService<>).GetTypeName();
}
return new ViewModelConfig(
mnemonic: type.GetTypeName(),
entity: type.GetTypeName(),
listView: new ListView(),
detailView: new DetailView(),
lookupProperty:
type.IsBaseObject()
? (type.GetProperty("Title") ?? type.GetProperty("Name") ?? type.GetProperty("ID")).Name
: "",
service: serviceName);
}
public void Handle_error(string id_, string jwtResponse, Type expectedExceptionType, int expectedCode, int expectedStatus, string expectedMessage, string expectedDeveloperMessage)
{
var testApiKey = ClientApiKeys.Builder()
.SetId("2EV70AHRTYF0JOA7OEFO3SM29")
.SetSecret("goPUHQMkS4dlKwl5wtbNd91I+UrRehCsEDJrIrMruK8")
.Build();
var fakeRequestExecutor = Substitute.For<IRequestExecutor>();
fakeRequestExecutor.ApiKey.Returns(testApiKey);
this.dataStore = TestDataStore.Create(fakeRequestExecutor, Caches.NewInMemoryCacheProvider().Build());
var request = new DefaultHttpRequest(HttpMethod.Get, new CanonicalUri($"https://foo.bar?{IdSiteClaims.JwtResponse}={jwtResponse}"));
IIdSiteSyncCallbackHandler callbackHandler = new DefaultIdSiteSyncCallbackHandler(this.dataStore, request);
try
{
var accountResult = callbackHandler.GetAccountResult();
throw new Exception("Should not reach here. Proper exception was not thrown.");
}
catch (IdSiteRuntimeException e) when (expectedExceptionType.IsAssignableFrom(e.GetType()))
{
e.Code.ShouldBe(expectedCode);
e.HttpStatus.ShouldBe(expectedStatus);
e.Message.ShouldBe(expectedMessage);
e.DeveloperMessage.ShouldBe(expectedDeveloperMessage);
}
catch (Exception e) when (expectedExceptionType.IsAssignableFrom(e.GetType()))
{
e.Message.ShouldStartWith(expectedMessage);
}
}
public bool CanReadFile (FilePath file, Type expectedObjectType)
{
if (expectedObjectType.IsAssignableFrom (typeof(Solution)) && String.Compare (file.Extension, ".sln", true) == 0) {
string ver = GetSlnFileVersion (file);
if (ver == "7.00" || ver == "8.00")
return true;
}
if (!expectedObjectType.IsAssignableFrom (typeof(DotNetProject)))
return false;
if (String.Compare (file.Extension, ".csproj", true) != 0 &&
String.Compare (file.Extension, ".vbproj", true) != 0)
return false;
try {
using (XmlReader xr = XmlReader.Create (file)) {
xr.MoveToContent ();
if (xr.NodeType == XmlNodeType.Element && String.Compare (xr.LocalName, "VisualStudioProject") == 0)
return true;
}
} catch {
return false;
}
return false;
}
/// <summary>
/// Get a function that coerces a sequence of one type into another type.
/// This is primarily used for aggregators stored in ProjectionExpression's,
/// which are used to represent the final transformation of the entire result set of a query.
/// </summary>
public static LambdaExpression Aggregate(Type expectedType, Type actualType)
{
Type actualElementType = actualType.GetSequenceElementType();
if (!expectedType.IsAssignableFrom(actualType))
{
Type expectedElementType = expectedType.GetSequenceElementType();
ParameterExpression p = Expression.Parameter(actualType, "p");
Expression body = null;
if (expectedType.IsAssignableFrom(actualElementType))
body = Expression.Call(typeof(Enumerable), "SingleOrDefault", new Type[] { actualElementType }, p);
else if (expectedType.IsGenericType && expectedType.GetGenericTypeDefinition() == typeof(IQueryable<>))
body = Expression.Call(typeof(Queryable), "AsQueryable", new Type[] { expectedElementType },
CoerceElement(expectedElementType, p));
else if (expectedType.IsArray && expectedType.GetArrayRank() == 1)
body = Expression.Call(typeof(Enumerable), "ToArray", new Type[] { expectedElementType },
CoerceElement(expectedElementType, p));
else if (expectedType.IsAssignableFrom(typeof(List<>).MakeGenericType(actualElementType)))
body = Expression.Call(typeof(Enumerable), "ToList", new Type[] { expectedElementType },
CoerceElement(expectedElementType, p));
else
{
ConstructorInfo ci = expectedType.GetConstructor(new Type[] { actualType });
if (ci != null)
body = Expression.New(ci, p);
}
if (body != null)
return Expression.Lambda(body, p);
}
return null;
}
/// <summary>
/// Get a function that coerces a sequence of one type into another type.
/// This is primarily used for aggregators stored in ProjectionExpression's, which are used to represent the
/// final transformation of the entire result set of a query.
/// </summary>
public static LambdaExpression GetAggregator(Type expectedType, Type actualType)
{
Type actualElementType = TypeHelper.GetElementType(actualType);
if (!expectedType.IsAssignableFrom(actualType))
{
Type expectedElementType = TypeHelper.GetElementType(expectedType);
ParameterExpression p = Expression.Parameter(actualType, "p");
Expression body = null;
if (expectedType.IsAssignableFrom(actualElementType))
{
body = Expression.Call(typeof(Enumerable), "SingleOrDefault", new Type[] { actualElementType }, p);
}
else if (expectedType.IsGenericType
&&
(expectedType == typeof(IQueryable) || expectedType == typeof(IOrderedQueryable)
|| expectedType.GetGenericTypeDefinition() == typeof(IQueryable<>)
|| expectedType.GetGenericTypeDefinition() == typeof(IOrderedQueryable<>)))
{
body = Expression.Call(
typeof(Queryable), "AsQueryable", new Type[] { expectedElementType }, CoerceElement(expectedElementType, p));
if (body.Type != expectedType)
{
body = Expression.Convert(body, expectedType);
}
}
else if (expectedType.IsArray && expectedType.GetArrayRank() == 1)
{
body = Expression.Call(
typeof(Enumerable), "ToArray", new Type[] { expectedElementType }, CoerceElement(expectedElementType, p));
}
else if (expectedType.IsGenericType && expectedType.GetGenericTypeDefinition().IsAssignableFrom(typeof(IList<>)))
{
var gt = typeof(DeferredList<>).MakeGenericType(expectedType.GetGenericArguments());
var cn =
gt.GetConstructor(new Type[] { typeof(IEnumerable<>).MakeGenericType(expectedType.GetGenericArguments()) });
body = Expression.New(cn, CoerceElement(expectedElementType, p));
}
else if (expectedType.IsAssignableFrom(typeof(List<>).MakeGenericType(actualElementType)))
{
// List<T> can be assigned to expectedType
body = Expression.Call(
typeof(Enumerable), "ToList", new Type[] { expectedElementType }, CoerceElement(expectedElementType, p));
}
else
{
// some other collection type that has a constructor that takes IEnumerable<T>
ConstructorInfo ci = expectedType.GetConstructor(new Type[] { actualType });
if (ci != null)
{
body = Expression.New(ci, p);
}
}
if (body != null)
{
return Expression.Lambda(body, p);
}
}
return null;
}
public object ReadFile(FilePath file, Type expectedType, IProgressMonitor monitor)
{
if (expectedType.IsAssignableFrom(typeof(WorkspaceItem)))
return DubFileManager.Instance.LoadAsSolution(file, monitor);
if (expectedType.IsAssignableFrom(typeof(SolutionEntityItem)))
return DubFileManager.Instance.LoadProject(file, Ide.IdeApp.Workspace.GetAllSolutions().First(), monitor);
return null;
}
/// <summary>
/// Gets an array of <see cref="Type"/>s that are assignable from the given type with the
/// specified <see cref="IDefinitionManager"/>.
/// </summary>
/// <param name="type">The <see cref="System.Type"/> to find other types that are
/// assignable from this type.</param>
/// <returns>An array of <see cref="Type"/>s which the given type is assignable from.</returns>
public static Type[] GetTypesAssignableFrom(this IDefinitionManager definitions, Type type)
{
Type[] result = definitions.GetDefinitions()
.Where(definition => type.IsAssignableFrom(definition.ItemType)
&& type.IsAssignableFrom(definition.ItemType))
.Select(definition => definition.ItemType)
.ToArray();
return result;
}
public static IEnumerable<Type> GetAllTypesImplementingOpenGenericType(this Assembly assembly, Type openGenericType)
{
return from type in assembly.GetExportedTypes()
from z in type.GetInterfaces()
let y = type.BaseType
where
(y != null && y.IsGenericType && openGenericType.IsAssignableFrom(y.GetGenericTypeDefinition())) ||
(z.IsGenericType && openGenericType.IsAssignableFrom(z.GetGenericTypeDefinition()))
select type;
}
public bool CanReadFile (FilePath file, Type expectedType)
{
string ext = Path.GetExtension (file).ToLower ();
if (ext == ".mds" && expectedType.IsAssignableFrom (typeof(Solution)))
return true;
else if (ext == ".mdp" && expectedType.IsAssignableFrom (typeof(Project)))
return true;
else if (ext == ".mdw" && expectedType.IsAssignableFrom (typeof(WorkspaceItem)))
return true;
return ext == ".mdse" && expectedType.IsAssignableFrom (typeof(SolutionEntityItem));
}
public static bool IsAssignable (Type to, Type from) {
if (to == null)
throw new ArgumentNullException("to");
if (to.IsAssignableFrom (from))
return true;
if (to.IsGenericType && from.IsGenericTypeDefinition)
return to.IsAssignableFrom (from.MakeGenericType (to.GetGenericArguments ()));
return false;
}
/// <summary>
/// Initialize an instance of ObjectMapper
/// </summary>
/// <param name="inputType"></param>
/// <param name="outputType"></param>
public ObjectMapper(Type inputType, Type outputType)
{
Check.Require(inputType, "inputType");
Check.Require(outputType, "outputType");
Check.Require(!inputType.IsAssignableFrom(typeof(DataTable)), "intput type could not be DataTable,pls use datarow instead.");
Check.Require(!outputType.IsAssignableFrom(typeof(DataTable)), "output type could not be DataTable,pls use datarow instead.");
Check.Require(!outputType.IsAssignableFrom(typeof(IDataReader)), "output type could not be IDataReader.");
this.inputType = inputType;
this.outputType = outputType;
this.initType = outputType;
}
public static IEnumerable<Type> GetAllTypesImplementingOpenGenericType(Type openGenericType, Assembly assembly)
{
return from x in Assembly.GetAssembly(typeof(Program)).GetTypes()
from z in x.GetInterfaces()
let y = x.BaseType
where
(y != null && y.IsGenericType &&
openGenericType.IsAssignableFrom(y.GetGenericTypeDefinition())) ||
(z.IsGenericType &&
openGenericType.IsAssignableFrom(z.GetGenericTypeDefinition()))
select x;
}
public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
{
if (absoluteUri != null && absoluteUri.IsFile && ofObjectToReturn.IsAssignableFrom(typeof(FileStream)))
{
// local file: return a stream on it. This might be the main file we are checking.
var path = absoluteUri.LocalPath;
return new FileStream(path, FileMode.Open);
}
if (ofObjectToReturn.IsAssignableFrom(typeof(MemoryStream)))
return new MemoryStream();
return null;
}
public bool CanReadFile (FilePath file, Type expectedType)
{
if (expectedType.IsAssignableFrom (typeof(Solution)) && slnFileFormat.CanReadFile (file, this))
return true;
else if (expectedType.IsAssignableFrom (typeof(SolutionEntityItem))) {
if (!MSBuildProjectService.CanReadFile (file))
return false;
//TODO: check ProductVersion first
return SupportsToolsVersion (ReadToolsVersion (file));
}
return false;
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
IPAddress addr = value as IPAddress;
if (addr == null)
return base.ConvertTo(context, culture, value, destinationType);
else if (destinationType.IsAssignableFrom(typeof(String)))
return addr.ToString();
else if (destinationType.IsAssignableFrom(typeof(byte[])))
return addr.GetAddressBytes();
else
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// During serialization, deserialization, and schema import and export, returns a data contract type that substitutes the specified type.
/// </summary>
/// <returns>
/// The <see cref="T:System.Type"/> to substitute for the <paramref name="type"/> value. This type must be serializable by the <see cref="T:System.Runtime.Serialization.DataContractSerializer"/> . For example, it must be marked with the <see cref="T:System.Runtime.Serialization.DataContractAttribute"/> attribute or other mechanisms that the serializer recognizes.
/// </returns>
/// <param name="type">
/// The CLR type <see cref="T:System.Type"/> to substitute.
/// </param>
public Type GetDataContractType(Type type)
{
if (type.IsAssignableFrom(typeof(StateTracker)))
{
return typeof(StateTrackerSurrogated);
}
if (type.IsAssignableFrom(typeof(StateMachineInfo)))
{
return typeof(StateMachineInfoSurrogated);
}
return type;
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (targetType.IsAssignableFrom(typeof(bool)) && targetType.IsAssignableFrom(typeof(string)))
{
throw new ArgumentException("EnumBoolConverter can only convert to boolean or string.");
}
if (targetType == typeof(string))
{
return value.ToString();
}
return string.Compare(value.ToString(), (string)parameter, StringComparison.InvariantCultureIgnoreCase) == 0;
}
public bool CanReadFile (FilePath file, Type expectedType)
{
if (file.FileName != "Makefile") return false;
MonoMakefile mkfile = new MonoMakefile (file);
if (mkfile.Content.IndexOf ("build/rules.make") == -1) return false;
if (mkfile.GetVariable ("LIBRARY") != null) return expectedType.IsAssignableFrom (typeof(DotNetProject));
if (mkfile.GetVariable ("PROGRAM") != null) return expectedType.IsAssignableFrom (typeof(DotNetProject));
string subdirs = mkfile.GetVariable ("SUBDIRS");
if (subdirs != null && subdirs.Trim (' ','\t') != "")
return expectedType.IsAssignableFrom (typeof(Solution)) || expectedType.IsAssignableFrom (typeof(SolutionFolder));
return false;
}
public static bool CheckIsVBugClass(Type type)
{
if (vBugClassTable.ContainsKey(type)) {
return vBugClassTable[type];
} else {
if (type.FullName.ToLower().Contains("vbug") || type.IsAssignableFrom(typeof(vBugHiddenUniqueComponent<>)) || type.IsAssignableFrom(typeof(BaseActivityGrabber<>))){
vBugClassTable.Add(type, true);
return true;
} else {
vBugClassTable.Add(type, false);
return false;
}
}
}
private object Create(Type targetType,string name)
{
if(Cache.ContainsKey(name))
{
var instance = Cache[name];
if (instance != null && targetType.IsAssignableFrom(instance.GetType())) return instance;
}
if (Assemblies != null)
{
foreach (var assembly in Assemblies)
{
foreach (var manifestResourceName in assembly.GetManifestResourceNames())
{
bool ignore = false;
if(ManifestResourceNameIgnorePatterns != null)
{
foreach(var ignore_pattern in ManifestResourceNameIgnorePatterns)
{
if (manifestResourceName.Contains(ignore_pattern)) ignore = true;
}
}
if (!ignore)
{
if (manifestResourceName == name || (manifestResourceName.Contains(name) && !RequireExactMatch))
{
object instance = null;
try
{
instance = ReadFunction(assembly.GetManifestResourceStream(manifestResourceName));
}
catch (Exception e)
{
throw new Exception($"ReadFunction failed on ManifestResourceName '{manifestResourceName}'", e);
}
if (instance != null)
{
if (targetType.IsAssignableFrom(instance.GetType()))
{
Cache[name] = instance;
return instance;
}
}
}
}
}
}
}
return null;
}
public static object GetService(Type t, IServiceContext localContext)
{
var loadedAssemblies = new Assembly[] { localContext.GetType().Assembly };
object service = null;
if (!_loadedServices.ContainsKey(localContext))
{
_loadedServices.Add(localContext, new List<object>());
}
var loadedServicesTemp = _loadedServices[localContext];
foreach (var serviceTemp in loadedServicesTemp)
{
if (t.IsAssignableFrom(serviceTemp.GetType()))
{
service = serviceTemp;
}
}
if (service == null)
{
foreach (var assembly in loadedAssemblies)
{
foreach (var module in assembly.GetModules())
{
foreach (var type in module.GetTypes())
{
if (t.IsAssignableFrom(type))
{
var constructor = type.GetConstructor(new Type[] { typeof(LocalContext) });
if (constructor != null)
{
service = (constructor.Invoke(new object[] { localContext }));
loadedServicesTemp.Add(service);
}
}
}
}
}
}
if (service != null)
{
return service;
}
throw new InvalidPluginExecutionException(string.Format("Service '{0}' not found", t.Name));
}
public static T ChkOtherObject <T>(this ILuaState self, int index, System.Type type) where T : class
{
if (self.IsNil(index))
{
return(null);
}
object obj = self.ToUserData(index);
if (obj == null)
{
self.L_ArgError(index, string.Format("{0} expected, got nil", type.Name));
return(null);
}
var tObj = obj as T;
if (tObj == null)
{
self.L_ArgError(index, string.Format("{0} expected, got nil", type.Name));
return(null);
}
System.Type objType = tObj.GetType();
if (type == objType || type.IsAssignableFrom(objType))
{
return(tObj);
}
self.L_ArgError(index, string.Format("{0} expected, got {1}", type.Name, objType.Name));
return(null);
}
public static object ChkUserData(this ILuaState self, int index, System.Type type)
{
if (self.IsNil(index))
{
return(null);
}
var luaT = self.Type(index);
if (luaT != LuaTypes.LUA_TUSERDATA && luaT != LuaTypes.LUA_TLIGHTUSERDATA)
{
self.L_ArgError(index, string.Format("{0} expected, got {1}", type.FullName, luaT));
return(null);
}
object obj = self.ToUserData(index);
if (obj == null)
{
self.L_ArgError(index, string.Format("{0} expected, got nil", type.FullName));
return(null);
}
System.Type objType = obj.GetType();
if (type == objType || type.IsAssignableFrom(objType))
{
return(obj);
}
self.L_ArgError(index, string.Format("{0} expected, got {1}", type.FullName, objType.Name));
return(null);
}
private static int __newindex_Array(ILuaState L)
{
System.Array obj = L.ChkUserDataSelf(1, CLASS) as System.Array;
if (obj == null)
{
L.L_Error("trying to newindex an invalid Array reference");
return(0);
}
int index = L.ChkInteger(2);
object val = L.ToAnyObject(3);
var valType = val.GetType();
System.Type type = obj.GetType().GetElementType();
if (!type.IsAssignableFrom(valType))
{
L.L_Error(string.Format("trying to set object type is not correct: {0} expected, got {1}", type, valType));
return(0);
}
val = System.Convert.ChangeType(val, type);
obj.SetValue(val, index);
return(0);
}
/// <summary>
/// Get objects with specific type (include derived objects) with enumerable method
/// </summary>
/// <returns></returns>
public static IEnumerable <object> GetObjectsEnumerable(System.Type theType)
{
foreach (System.Type aType in itsListSorted.Keys)
{
if (theType.IsAssignableFrom(aType))
{
List <KGFObject> aListObjectScripts = itsListSorted[aType];
for (int i = aListObjectScripts.Count - 1; i >= 0; i--)
{
object anObject = aListObjectScripts[i];
MonoBehaviour aMonobehaviour = (MonoBehaviour)aListObjectScripts[i];
if (aMonobehaviour == null)
{
aListObjectScripts.RemoveAt(i);
continue;
}
if (aMonobehaviour.gameObject == null)
{
aListObjectScripts.RemoveAt(i);
continue;
}
yield return(anObject);
}
}
}
yield break;
}
private object GetValue(DateTime dateTime, Type type, TypeConverter converter)
{
if (type.IsAssignableFrom(typeof(DateTime)))
return dateTime;
else
return converter.ConvertFrom(dateTime);
}
/// <summary>
/// Gets the given <paramref name="implementationType" />'s constructor that can be used by the
/// container to create that instance.
/// </summary>
/// <param name="serviceType">Type of the abstraction that is requested.</param>
/// <param name="implementationType">Type of the implementation to find a suitable constructor for.</param>
/// <returns>
/// The <see cref="T:System.Reflection.ConstructorInfo" />.
/// </returns>
/// <exception cref="T:SimpleInjector.ActivationException">Thrown when no suitable constructor could be found.</exception>
public ConstructorInfo GetConstructor(Type serviceType, Type implementationType)
{
// note: this I want in the future to be pushed out to a rule overrides folder
if (typeof(EntitiesContext).IsAssignableFrom(implementationType))
{
var defaultconstructor =
(from constructor in implementationType.GetConstructors()
where constructor.GetParameters().Count() == 0
select constructor).Take(1);
if (defaultconstructor.Any()) return defaultconstructor.First();
}
if (serviceType.IsAssignableFrom(implementationType))
{
var longestConstructor =
(from constructor in implementationType.GetConstructors()
orderby constructor.GetParameters().Count() descending
select constructor).Take(1);
if (longestConstructor.Any()) return longestConstructor.First();
}
// fall back to the container's default behavior.
return _originalBehavior.GetConstructor(serviceType, implementationType);
}
/// <summary>
/// 把指定索引的值转成指定类型的UnityEngine.Component
/// 如果类型不匹配，尝试获取其相关的GameObject，
/// 再从GameoObject上获取其挂载的Component
/// </summary>
public static Component ToComponent(this ILuaState self, int index, System.Type type)
{
var obj = self.ToAnyObject(index);
if (obj == null)
{
return(null);
}
if (type.IsAssignableFrom(obj.GetType()))
{
return(obj as Component);
}
var com = obj as Component;
if (com)
{
return(com.gameObject.GetComponent(type));
}
var go = obj as GameObject;
if (go == null)
{
go = self.ToGameObject(index);
}
if (go)
{
return(go.GetComponent(type));
}
return(null);
}
public override Expression/*!*/ ConvertExpression(Expression/*!*/ expr, Type/*!*/ toType, ConversionResultKind kind, Expression context) {
ContractUtils.RequiresNotNull(expr, "expr");
ContractUtils.RequiresNotNull(toType, "toType");
Type exprType = expr.Type;
if (toType == typeof(object)) {
if (exprType.IsValueType) {
return AstUtils.Convert(expr, toType);
} else {
return expr;
}
}
if (toType.IsAssignableFrom(exprType)) {
return expr;
}
Type visType = CompilerHelpers.GetVisibleType(toType);
if (exprType == typeof(PythonType) && visType == typeof(Type)) {
return AstUtils.Convert(expr, visType); // use the implicit conversion
}
return Binders.Convert(
context,
_context.DefaultBinderState,
visType,
visType == typeof(char) ? ConversionResultKind.ImplicitCast : kind,
expr
);
}
public static bool Same(System.Type a, System.Type b)
{
return((
a.FullName == b.FullName) ||
b.IsAssignableFrom(a) ||
(a.IsAssignableFrom(b)
));
}
public override bool SupportsRemappedAssetType(System.Type type)
{
if (type.IsAssignableFrom(typeof(TextAsset)))
{
return(true);
}
return(false);
}
void Init(Type requiredType, Type defaultType, bool executesAfterDependency)
{
Assert.IsTrue(requiredType != null && defaultType != null, "ComponentDependency: types cannot be NULL");
Assert.IsTrue(!defaultType.IsAbstract, "ComponentDependency: default type " + defaultType.Name + " cannot be abstract");
Assert.IsTrue(typeof(Component).IsAssignableFrom(defaultType), "ComponentDependency: default type " + defaultType.Name + " is not a Component");
Assert.IsTrue(requiredType.IsAssignableFrom(defaultType), "ComponentDependency default type must be same as or assignable to required type");
defaultComponentType = defaultType;
m_executesAfterDependencies = executesAfterDependency;
}
public static Component GetComponent(int cacheId, System.Type type, bool needDecode = false)
{
var component = GetComponent(cacheId, needDecode);
if (component != null && type.IsAssignableFrom(component.GetType()))
{
return((Component)System.Convert.ChangeType(component, type));
}
return(null);
}
public static Component GetComponent(int cacheId, int index, System.Type type)
{
var component = GetComponent(cacheId, index);
if (component != null && type.IsAssignableFrom(component.GetType()))
{
return((Component)System.Convert.ChangeType(component, type));
}
return(null);
}
/// <summary>
/// Calculates the weapon damage based on the target
/// </summary>
/// <returns>damage</returns>
protected float GetDamage()
{
if (GetTarget() != null && bonusDamageType != null && GetTarget().GetComponent <Entity>())
{
if (bonusDamageType.IsAssignableFrom(GetTarget().GetComponent <Entity>().GetType()))
{
return((damage + Core.damageAddition) * bonusDamageMultiplier);
}
}
return(damage + Core.damageAddition);
}
protected static bool IsSameOrSubClassOrImplementInterface(System.Type p_potentialDescendant, System.Type p_potentialBase)
{
if (p_potentialBase != null && p_potentialDescendant != null)
{
bool v_sucess = p_potentialBase.IsAssignableFrom(p_potentialDescendant) || (new List <System.Type>(p_potentialDescendant.GetInterfaces())).Contains(p_potentialBase);
if (!v_sucess)
{
v_sucess = IsSameOrSubclass(p_potentialDescendant, p_potentialBase);
}
return(v_sucess);
}
return(false);
}
public static List <System.Type> GetTypes(System.Type aBaseType)
{
var res = new List <System.Type>();
foreach (var t in m_Types)
{
if (aBaseType.IsAssignableFrom(t))
{
res.Add(t);
}
}
return(res);
}
/**
* Find all activities which have data of a given class. Useful for finding custom activity types.
*/
virtual public List <Activity> GetActivitiesOfDataClassType(System.Type type)
{
List <Activity> result = new List <Activity>();
foreach (Activity activity in currentActivities)
{
ActivityData data = GetActivityData(activity.Type);
if (type.IsAssignableFrom(data.GetType()))
{
result.Add(activity);
}
}
foreach (Activity activity in completedActivities)
{
ActivityData data = GetActivityData(activity.Type);
if (type.IsAssignableFrom(data.GetType()))
{
result.Add(activity);
}
}
return(result);
}
private static bool OkToAdd(List <ScriptableObject> items, ScriptableObject item)
{
if (!item)
{
Debug.LogError("Can't set item to none.");
return(false);
}
if (!(item is IInputBuildProcessor))
{
Debug.LogError(string.Format("{0} does not implement {1}."
, item.name, typeof(IInputBuildProcessor).Name));
return(false);
}
if (items.Contains(item))
{
Debug.LogError(item.name + " already in the processor list.");
return(false);
}
IInputBuildProcessor pa = (IInputBuildProcessor)item;
if (pa.DuplicatesAllowed)
{
return(true);
}
foreach (ScriptableObject itemB in items)
{
IInputBuildProcessor pb = (IInputBuildProcessor)itemB;
if (pb.DuplicatesAllowed)
{
continue;
}
System.Type ta = pb.GetType();
System.Type tb = pa.GetType();
if (ta.IsAssignableFrom(tb) || tb.IsAssignableFrom(ta))
{
Debug.LogError(string.Format(
"Disallowed dulicate detected. {0} and {1} are same type."
, pa.Name, pb.Name));
return(false);
}
}
return(true);
}
public bool ParamsMatch(object param)
{
if (Param == null)
{
return(param == null);
}
if (param == null)
{
return(false);
}
return(Param.IsAssignableFrom(param.GetType()));
}
public static void Setup()
{
netMessageTypes = new List <System.Type>();
System.Type baseType = typeof(NetMessage);
System.Reflection.Assembly assembly = baseType.Assembly;
System.Type[] types = assembly.GetTypes();
foreach (System.Type type in types)
{
if (baseType.IsAssignableFrom(type))
{
netMessageTypes.Add(type);
}
}
}
public ItemStack(System.Type type)
{
itemType = type;
if (itemType == null)
{
if (!itemType.IsAssignableFrom(typeof(IInventoryItem)))
{
throw new UnityException("Type is not an item");
}
else
{
itemType = type;
}
}
}
private static bool IsAssignableFrom(System.Type to, System.Type from)
{
if (to.IsAssignableFrom(from))
{
return(true);
}
else if (to.IsArray && to.GetElementType().IsAssignableFrom(from))
{
return(true);
}
else if (from == typeof(Texture2D) && to == typeof(Sprite) || to.HasElementType && to.GetElementType() == typeof(Sprite))
{
return(true);
}
return(false);
}
private static void InitializeValidator(Attribute attribute, System.Type validatorClass, IValidator entityValidator)
{
/* This method was added to supply major difference between JAVA and NET generics.
* So far in JAVA the generic type is something optional, in NET mean "strongly typed".
* In this case we don't know exactly wich is the generic version of "IInitializableValidator<>"
* so we create the type on the fly and invoke the Initialize method by reflection.
* All this work is only to give to the user the ability of implement IInitializableValidator<>
* without need to inherit from a base class or implement a generic and a no generic version of
* the method Initialize.
*/
System.Type[] args = { attribute.GetType() };
System.Type concreteIvc = BaseInitializableType.MakeGenericType(args);
if (concreteIvc.IsAssignableFrom(validatorClass))
{
MethodInfo initMethod = concreteIvc.GetMethod("Initialize");
initMethod.Invoke(entityValidator, new object[] { attribute });
}
}
private static bool IsMatchingImplementor(string entityOrClassName, System.Type entityClass, IQueryable implementor)
{
var implementorClass = implementor.MappedClass;
if (implementorClass == null)
{
return(false);
}
if (entityClass == implementorClass)
{
// It is possible to have multiple mappings for the same entity class, but with different entity names.
// When querying for a specific entity name, we should only return entities for the requested entity name
// and not return entities for any other entity names that may map to the same entity class.
bool isEntityName = !entityOrClassName.Equals(entityClass.FullName);
return(!isEntityName || entityOrClassName.Equals(implementor.EntityName));
}
return(entityClass.IsAssignableFrom(implementorClass));
}
//TODO YAGNI add an ContainsAssignable function similar to containstype
/// <summary>
/// Checks the containedTypes list for duplicate types
/// </summary>
/// <param name="t">type to compare to conaintedtypes list</param>
/// <returns> true if there is a duplicate type</returns>
public bool ContainsAssignable(System.Type t)
{
System.Type st = null;
for (int i = 0; i < containedTypes.Count; i++)
{
st = containedTypes[i].SystemType;
if (st == null)
{
continue;
}
//Debug.Log("Comparing: " + st + " and " + t);
if (t.IsAssignableFrom(st))
{
return(true);
}
}
return(false);
}
public static System.Type[] GetTypesWithInterface(this System.AppDomain aAppDomain, System.Type aInterfaceType)
{
List <System.Type> result = new List <System.Type>();
System.Reflection.Assembly[] assemblies = aAppDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
var types = assembly.GetTypes();
foreach (var type in types)
{
if (aInterfaceType.IsAssignableFrom(type))
{
result.Add(type);
}
}
}
return(result.ToArray());
}
public static Dictionary <uint, string> GetAllDerivedTypes()
{
System.Type c = typeof(AkTriggerBase);
System.Type[] types = c.Assembly.GetTypes();
Dictionary <uint, string> dictionary = new Dictionary <uint, string>();
for (int i = 0; i < types.Length; i++)
{
if (types[i].IsClass && (types[i].IsSubclassOf(c) || (c.IsAssignableFrom(types[i]) && (c != types[i]))))
{
string name = types[i].Name;
dictionary.Add(AkUtilities.ShortIDGenerator.Compute(name), name);
}
}
dictionary.Add(AkUtilities.ShortIDGenerator.Compute("Awake"), "Awake");
dictionary.Add(AkUtilities.ShortIDGenerator.Compute("Start"), "Start");
dictionary.Add(AkUtilities.ShortIDGenerator.Compute("Destroy"), "Destroy");
return(dictionary);
}
/// <summary>Convert an object to another type</summary>
/// <param name="pNewType"></param>
/// <returns></returns>
public Instance CastAs(string pNewType)
{
System.Type lNewType = this.lBridge.GetLoadedTypeFromString(pNewType);
if (lNewType != null)
{
if (lNewType.IsAssignableFrom(this.lType))
{
return(new Instance(this.lBridge, lNewType, this.CurrentInstance));
}
else
{
throw new ApplicationException("Cast fail from Type <" + this.lType.FullName + "> to type <" + pNewType + ">! ");
}
}
else
{
throw new ApplicationException("Type <" + pNewType + "> not found! ");
}
}
/// <summary>
/// 字符串与枚举型、TimeSpan与整型之间转换的方法。
/// </summary>
/// <param name="srcType">源数据类型</param>
/// <param name="srcValue">源数据的值</param>
/// <param name="targetType">目标数据类型</param>
/// <returns>类型转换后的结果</returns>
/// <remarks>字符串与枚举型、TimeSpan与整型之间转换的方法。
/// <seealso cref="MCS.Library.Core.XmlHelper"/>
/// </remarks>
public static object ChangeType(System.Type srcType, object srcValue, System.Type targetType)
{
targetType.NullCheck(nameof(targetType));
bool dealed = false;
object result = null;
if (srcType == typeof(object))
{
if (srcValue != null)
{
srcType = srcValue.GetType();
}
}
foreach (ChangeTypeAction action in _changeTypeActions)
{
action(srcType, srcValue, targetType, ref result, ref dealed);
if (dealed)
{
break;
}
}
if (dealed == false)
{
if (targetType != typeof(object) && targetType.IsAssignableFrom(srcType))
{
result = srcValue;
}
else if (targetType == typeof(DateTime))
{
result = Convert.ToDateTime(srcValue);
}
else
{
result = Convert.ChangeType(srcValue, targetType);
}
}
return(result);
}
internal static object[] SmlToArray(this string data)
{
if (data.StartsWith(SMLSIG))
{
string[] l_vals = data.Split('|');
List <object> l_res = new List <object>();
for (int i = 1; i < l_vals.Length; i++)
{
string[] l_contents = l_vals[i].Split('~');
string l_typename = l_contents[0];
string l_val = l_contents[1].Remove(0, 1);
int l_rNumber = l_val[l_val.Length - 1] == '}' ? 1 : 2;
l_val = l_val.Remove(l_val.Length - l_rNumber, l_rNumber);
//Debug.Log(l_typename);
System.Type l_type = System.Type.GetType(l_typename);
System.Object l_resval = null;
if (l_val.Length > 0 && l_type != null && (l_type.IsAssignableFrom(typeof(IConvertible)) || l_type.IsPrimitive || l_type == typeof(string) || l_type.IsEnum))
{
if (l_type.IsEnum)
{
l_resval = Enum.Parse(l_type, l_val, true);
}
else
{
l_resval = Convert.ChangeType(l_val, l_type);
}
}
l_res.Add(l_resval);
//Debug.Log(l_resval);
}
return(l_res.ToArray());
}
else
{
Debug.LogError("sml sig not detected");
return(null);
}
}
public void MetaValue(object value, System.Type entityType)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (entityType == null)
{
throw new ArgumentNullException("entityType");
}
if (value is System.Type)
{
throw new ArgumentOutOfRangeException("value", "System.Type is invalid meta-type (you don't need to set meta-values).");
}
if (!elementType.IsAssignableFrom(entityType))
{
throw new ArgumentOutOfRangeException("entityType", string.Format("A {0} is not assignable to the collection's elements which type is {1}", entityType, elementType));
}
System.Type metavalueType = value.GetType();
if (manyToAny.metavalue == null)
{
manyToAny.metavalue = new HbmMetaValue[0];
}
Dictionary <string, string> values = manyToAny.metavalue.ToDictionary(mv => mv.value, mv => mv.@class);
MetaType(metavalueType);
string newClassMetavalue = entityType.GetShortClassName(mapDoc);
string metavalueKey = value.ToString();
string existingClassMetavalue;
if (values.TryGetValue(metavalueKey, out existingClassMetavalue) && existingClassMetavalue != newClassMetavalue)
{
throw new ArgumentException(
string.Format(
"Can't set two different classes for same meta-value (meta-value='{0}' old-class:'{1}' new-class='{2}')",
metavalueKey, existingClassMetavalue, newClassMetavalue));
}
values[metavalueKey] = newClassMetavalue;
manyToAny.metavalue = values.Select(vd => new HbmMetaValue {
value = vd.Key, @class = vd.Value
}).ToArray();
}
/// <summary>
/// Checks whether the proxy representing the specified object type can be cast to the type represented by the IRemotingTypeInfo interface
/// </summary>
/// <param name="toType">The Type we wish to cast to</param>
/// <param name="obj">The object we wish to cast</param>
/// <returns>True if the strict property is false, otherwise the list of supportedTypes is checked.<br>
/// The proxy targets type(s) are automatically supported</br></returns>
public bool CanCastTo(System.Type toType, object obj)
{
// Assume we can (which is the default unless strict is true)
bool canCast = true;
if (strict)
{
// First check if the proxyTarget supports the cast
if (toType.IsAssignableFrom(proxyTarget.GetType()))
{
canCast = true;
}
else if (supportedTypes != null)
{
canCast = false;
// Check if the list of supported interfaces supports the cast
foreach (Type type in supportedTypes)
{
if (toType == type)
{
canCast = true;
break;
}
}
}
else
{
canCast = false;
}
}
return(canCast);
}
static StackObject *IsAssignableFrom_12(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Type @c = (System.Type) typeof(System.Type).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.Type instance_of_this_method = (System.Type) typeof(System.Type).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.IsAssignableFrom(@c);
__ret->ObjectType = ObjectTypes.Integer;
__ret->Value = result_of_this_method ? 1 : 0;
return(__ret + 1);
}
