public static void Register(System.Type tp, IService service)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (!tp.IsClass || tp.IsAbstract || !typeof(IService).IsAssignableFrom(tp))
{
throw new System.ArgumentException("Type must be a concrete class that implements IService.", "tp");
}
System.Reflection.FieldInfo field;
try
{
var klass = typeof(Entry <>);
klass = klass.MakeGenericType(tp);
field = klass.GetField("Instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
}
catch (System.Exception ex)
{
throw new System.InvalidOperationException("Failed to resolve type '" + tp.Name + "'.", ex);
}
if (field == null)
{
throw new System.InvalidOperationException("Failed to resolve type '" + tp.Name + "'.");
}
if (field.GetValue(null) != null)
{
throw new System.InvalidOperationException("You must first unregister a service before registering a new one.");
}
field.SetValue(null, service);
}
public static void Unregister(System.Type tp, bool donotSignalUnregister = false)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (!tp.IsClass || tp.IsAbstract || !typeof(IService).IsAssignableFrom(tp))
{
throw new System.ArgumentException("Type must be a concrete class that implements IService.", "tp");
}
IService inst;
try
{
var klass = typeof(Entry <>);
klass = klass.MakeGenericType(tp);
var field = klass.GetField("Instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
inst = field.GetValue(null) as IService;
if (inst != null)
{
field.SetValue(null, null);
}
}
catch (System.Exception ex)
{
throw new System.InvalidOperationException("Failed to resolve type '" + tp.Name + "'.", ex);
}
if (!donotSignalUnregister && inst != null)
{
inst.SignalServiceUnregistered();
}
}
public static T GetOrCreate(System.Type tp, bool persistent = false, string name = null)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (!typeof(ScriptableObject).IsAssignableFrom(tp) || !typeof(T).IsAssignableFrom(tp))
{
throw new System.ArgumentException("Type must be a Component that implements " + typeof(T).Name);
}
var inst = Services.Get <T>();
if (inst != null)
{
return(inst);
}
if (name == null)
{
name = "Service." + typeof(T).Name;
}
var obj = ScriptableObject.CreateInstance(tp) as ScriptableObject;
obj.name = name;
return(obj as T);
}
string[] _getTypeNames(System.Type typeBase, string[] assemblyNames)
{
List <string> typeNames = new List <string>();
foreach (string assemblyName in assemblyNames)
{
Assembly assembly = null;
try
{
assembly = Assembly.Load(assemblyName);
}
catch
{
continue;
}
if (assembly == null)
{
continue;
}
System.Type[] types = assembly.GetTypes();
foreach (System.Type type in types)
{
if (type.IsClass && !type.IsAbstract && typeBase.IsAssignableFrom(type))
{
typeNames.Add(type.FullName);
}
}
}
typeNames.Sort();
return(typeNames.ToArray());
}
private static System.Reflection.FieldInfo GetStaticEntryFieldInfo(System.Type tp, bool createIfNotFound)
{
System.Reflection.FieldInfo result = null;
if (_staticFieldTable.TryGetValue(tp, out result))
{
return(result);
}
if (createIfNotFound)
{
try
{
var klass = typeof(Entry <>);
klass = klass.MakeGenericType(tp);
result = klass.GetField("Instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
_staticFieldTable[tp] = result;
}
catch (System.Exception ex)
{
throw new System.InvalidOperationException("Failed to resolve type '" + tp.Name + "'.", ex);
}
}
return(result);
}
public static T GetOrCreate(System.Type tp, bool persistent = false, string name = null)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (!typeof(Component).IsAssignableFrom(tp) || !typeof(T).IsAssignableFrom(tp))
{
throw new System.ArgumentException("Type must be a Component that implements " + typeof(T).Name);
}
var inst = Services.Get <T>();
if (inst != null)
{
return(inst);
}
if (name == null)
{
name = "Service." + typeof(T).Name;
}
var go = new GameObject(name);
if (persistent)
{
GameObject.DontDestroyOnLoad(go);
}
return(go.AddComponent(tp) as T);
}
object IConvertible.ToType(System.Type conversionType, IFormatProvider?provider)
{
if (Proxies.ContainsKey(conversionType))
{
return(Proxies[conversionType]);
}
if (ToTypeCore(out var converted))
{
return(Proxies[conversionType] = converted !);
}
throw new InvalidCastException($"Unable to cast {this.GetType().FullName} into {conversionType.FullName}");
bool ToTypeCore(out object?result)
{
if (!conversionType.IsInstanceOfType(this))
{
return(MakeProxy(conversionType, false, out result));
}
result = this;
return(true);
}
}
/// <summary>
/// Imports values from external source
/// </summary>
/// <param name="importer">User who importing values</param>
/// <param name="vocabularyType">Type of vocabulary</param>
/// <param name="source">External source</param>
public Dictionary <string, string> Import(User importer, System.Type vocabularyType, IExternalVocabularySource source)
{
var newValuesArray = source.GetValuesFromFile();
_extensibleVocabularyService.AddNewExtendedValuesBy(importer.Id, vocabularyType, newValuesArray);
return(newValuesArray);
}
private void _instantiationCreateType()
{
if (_oldSelectIndex != _createTypeSelectIndex || _localizationCreate == null)
{
System.Type createType = _getType(_LocalizationCreateTypes[_createTypeSelectIndex]);
_localizationCreate = (LocalizationCreateAndParseBase)Activator.CreateInstance(createType);
_oldSelectIndex = _createTypeSelectIndex;
}
}
public static bool Exists(System.Type tp)
{
IService serv;
if (_serviceTable.TryGetValue(tp, out serv))
{
return(!serv.IsNullOrDestroyed());
}
return(false);
}
//----------------------------------------------------------------------
static object CreateDefaultObject(System.Type type)
{
if (type.IsValueType)
{
return(Activator.CreateInstance(type));
}
if (CanSerialiseEnumerable(type))
{
var elementType = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
return(Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[] { elementType })));
}
return(null);
}
static System.Type GetType(string name)
{
System.Type type = null;
var assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < assemblies.Length; i++)
{
type = assemblies[i].GetType(name);
if (type != null)
{
break;
}
}
return(type);
}
protected static void SetStaticProperty <T>(System.Type type, T value, [CallerMemberName] string?propertyName = null)
{
type = type ?? throw new ArgumentNullException(nameof(type));
propertyName = propertyName ?? throw new ArgumentNullException(nameof(propertyName));
JsiiTypeAttributeBase.Load(type.Assembly);
var classAttribute = ReflectionUtils.GetClassAttribute(type) !;
var propertyAttribute = GetStaticPropertyAttribute(type, propertyName);
SetPropertyCore(
value,
propertyAttribute,
(client, jsiiValue) => client.StaticSet(classAttribute.FullyQualifiedName, propertyAttribute.Name, jsiiValue)
);
}
//----------------------------------------------------------------------
static object CreateDefaultObject(System.Type type)
{
if (type.IsValueType)
{
return((object)System.Activator.CreateInstance(type));
}
if (CanSerialiseGenericList(type) && SUPPORT_LISTS)
{
return((object)System.Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[] { type })));
}
if (CanSerialiseArray(type))
{
return((object)System.Array.CreateInstance(type.GetElementType(), 0));
}
return(null);
}
public static TServiceType GetOrCreate <TServiceType>(System.Type concreteType, bool persistent = false, string name = null) where TServiceType : class, IService
{
if (concreteType == null)
{
throw new System.ArgumentNullException("concreteType");
}
if (!typeof(TServiceType).IsAssignableFrom(concreteType))
{
throw new System.ArgumentException("Type must implement " + typeof(TServiceType).Name);
}
var inst = Services.Get <TServiceType>();
if (inst != null)
{
return(inst);
}
if (typeof(Component).IsAssignableFrom(concreteType))
{
var obj = ServiceComponent <TServiceType> .Create(concreteType, persistent, name);
Services.Register <TServiceType>(obj);
return(obj);
}
else if (typeof(ScriptableObject).IsAssignableFrom(concreteType))
{
var obj = ServiceScriptableObject <TServiceType> .Create(concreteType, persistent, name);
Services.Register <TServiceType>(obj);
return(obj);
}
else
{
try
{
var obj = System.Activator.CreateInstance(concreteType) as TServiceType;
Services.Register <TServiceType>(obj);
return(obj);
}
catch (System.Exception ex)
{
throw new System.InvalidOperationException("Supplied concrete service type failed to construct.", ex);
}
}
}
private static bool InterfaceIsActionDelegate(System.Type type)
{
if (type == typeof(IFsmActionDelegate))
{
return(true);
}
foreach (var i in type.GetInterfaces())
{
if (InterfaceIsActionDelegate(i))
{
return(true);
}
}
return(false);
}
protected static T InvokeStaticMethod <T>(System.Type type, System.Type[] parameterTypes, object?[] arguments, [CallerMemberName] string methodName = "")
{
JsiiTypeAttributeBase.Load(type.Assembly);
var methodAttribute = GetStaticMethodAttribute(type, methodName, parameterTypes);
var classAttribute = ReflectionUtils.GetClassAttribute(type) !;
return(InvokeMethodCore <T>(
methodAttribute,
arguments,
(client, args) => throw new NotSupportedException("Async static methods are currently not supported"),
(client, args) => client.StaticInvoke(
classAttribute.FullyQualifiedName,
methodAttribute.Name,
ConvertArguments(methodAttribute.Parameters, arguments)
)
));
}
/// <summary>
/// Returns list of vocabulary values
/// </summary>
/// <param name="vocabularyType">Type of vocabulary</param>
/// <returns>List of vocabulary values</returns>
public IEnumerable <VocabularyValue> GetVocabularyValuesExtended(System.Type vocabularyType, string itemType, string search, string userId)
{
var plugins = _pluginsProvider.GetPluginsFor(vocabularyType).ToList();
var stringValues = new List <VocabularyValue>();
foreach (var plugin in plugins)
{
var vocabularyPlugin = plugin as IVocabularyExtenalSourcePlugin;
if (vocabularyPlugin != null)
{
stringValues.AddRange(vocabularyPlugin.GetValuesExtended(search, itemType));
}
}
var pluginsCollection = stringValues.Distinct().ToList();
var systemCollection = _extensibleVocabularyService.GetAllExtenededValues(vocabularyType, userId).Where(v => v.Value.StartsWith(search)).ToList();
if ("Country".ToLower() == itemType.ToLower())
{
foreach (var item in pluginsCollection.Select(f => f.Value).Distinct().ToList())
{
if (null == systemCollection.FirstOrDefault(c => c.Value == item))
{
systemCollection.Add(new VocabularyValue {
Value = item.First().ToString().ToUpper() + item.Substring(1)
});
}
}
}
if (itemType.ToLower() == "class" || itemType.ToLower() == "order" || itemType.ToLower() == "family")
{
systemCollection.AddRange(pluginsCollection.Select(f => f.Value).Distinct().Select(p => new VocabularyValue {
Value = p
}));
}
if ("LocationName".ToLower() == itemType.ToLower())
{
systemCollection.AddRange(pluginsCollection.Distinct());
}
return(systemCollection.OrderBy(o => o.Value));
}
public static TServiceType Create <TServiceType>(System.Type concreteType, bool persistent = false, string name = null) where TServiceType : class, IService
{
var inst = Services.Get <TServiceType>();
if (inst != null)
{
throw new System.InvalidOperationException(string.Format("A service of type '{0}' already exists.", typeof(TServiceType).Name));
}
var serv = CreateUnregisteredService <TServiceType>(concreteType, persistent, name);
if (serv == null)
{
return(null);
}
Register <TServiceType>(serv);
return(serv);
}
public static TServiceType GetOrCreate <TServiceType>(System.Type concreteType, bool persistent = false, string name = null) where TServiceType : class, IService
{
var inst = Services.Get <TServiceType>();
if (inst != null)
{
return(inst);
}
var serv = CreateUnregisteredService <TServiceType>(concreteType, persistent, name);
if (serv == null)
{
return(null);
}
Register <TServiceType>(serv);
return(serv);
}
//----------------------------------------------------------------------
static bool CanSerialiseType(System.Type _type)
{
var param = !_type.IsEnum ? _type : typeof(System.Enum);
if (!UnitySerialiseFieldByType.ContainsKey(_type))
{
if (typeof(UnityEngine.Object).IsAssignableFrom(_type))
{
var methodTemplate = typeof(MonoBehaviourEditor).GetMethod("DrawMonobehaviour", BindingFlags.Static | BindingFlags.NonPublic);
var newMethod = methodTemplate.MakeGenericMethod(_type);
var serialiseDelegate = (SerialiseParameter)Delegate.CreateDelegate(typeof(SerialiseParameter), newMethod);
UnitySerialiseFieldByType.Add(_type, serialiseDelegate);
}
if (!UnitySerialiseFieldByType.ContainsKey(_type))
{
return(false);
}
}
return(UnitySerialiseFieldByType.ContainsKey(param));
}
//----------------------------------------------------------------------
static bool CanSerialiseGenericList(System.Type _type)
{
if (!SUPPORT_LISTS)
{
return(false);
}
if (!_type.IsGenericType || _type.GetGenericTypeDefinition() != typeof(List <>))
{
return(false);
}
var parameters = _type.GetGenericArguments();
if (parameters.Length > 1)
{
return(false);
}
var param = !parameters[0].IsEnum ? parameters[0] : typeof(System.Enum);
return(UnitySerialiseFieldByType.ContainsKey(param));
}
//----------------------------------------------------------------------
static bool CanSerialiseEnumerable(System.Type _type)
{
//array
if (_type.IsArray)
{
return(CanSerialiseType(_type.GetElementType()));
}
//list<T>
if (!_type.IsGenericType || _type.GetGenericTypeDefinition() != typeof(List <>))
{
return(false);
}
var parameters = _type.GetGenericArguments();
if (parameters.Length > 1)
{
return(false);
}
return(CanSerialiseType(parameters[0]));
}
private static JsiiPropertyAttribute GetPropertyAttributeCore(System.Type type, string propertyName, BindingFlags bindingFlags)
{
type = type ?? throw new ArgumentNullException(nameof(type));
propertyName = propertyName ?? throw new ArgumentNullException(nameof(propertyName));
var propertyInfo = type.GetProperty(propertyName, bindingFlags);
if (propertyInfo == null)
{
throw new ArgumentException($"Property {propertyName} does not exist", nameof(propertyName));
}
var attribute = propertyInfo.GetCustomAttribute <JsiiPropertyAttribute>();
if (attribute == null)
{
throw new ArgumentException($"Property {propertyName} is missing JsiiPropertyAttribute", nameof(propertyName));
}
return(attribute);
}
public static void Register(System.Type tp, IService service)
{
if (tp == null)
{
throw new System.ArgumentNullException("tp");
}
if (service.IsNullOrDestroyed())
{
throw new System.ArgumentNullException("service");
}
if (!typeof(IService).IsAssignableFrom(tp))
{
throw new System.ArgumentException("Type must implement IService.", "tp");
}
if (!tp.IsAssignableFrom(service.GetType()))
{
throw new System.ArgumentException(string.Format("Service must implement the service type '{0}' it's being registered for.", tp.Name), "tp");
}
System.Reflection.FieldInfo field = GetStaticEntryFieldInfo(tp, true);
if (field == null)
{
throw new System.InvalidOperationException("Failed to resolve type '" + tp.Name + "'.");
}
var other = field.GetValue(null);
if (!other.IsNullOrDestroyed() && !object.ReferenceEquals(other, service))
{
throw new System.InvalidOperationException("You must first unregister a service before registering a new one.");
}
_services.Add(service);
field.SetValue(null, service);
_serviceTable[tp] = service;
//make sure we don't add it multiple times
service.Disposed -= OnServiceInadvertentlyDisposed;
service.Disposed += OnServiceInadvertentlyDisposed;
}
/// <summary>
/// Returns list of vocabulary values
/// </summary>
/// <param name="vocabularyType">Type of vocabulary</param>
/// <returns>List of vocabulary values</returns>
public IEnumerable <VocabularyValue> GetVocabularyValues(System.Type vocabularyType, string userId)
{
var resultCollection = new List <VocabularyValue>();
resultCollection.AddRange(_extensibleVocabularyService.GetAllExtenededValues(vocabularyType, userId).ToList());
resultCollection.AddRange(_extensibleVocabularyService.GetExtenededValuesBy(userId, vocabularyType));
var plugins = _pluginsProvider.GetPluginsFor(vocabularyType).ToList();
foreach (var plugin in plugins)
{
var vocabularyPlugin = plugin as IVocabularyExtenalSourcePlugin;
if (vocabularyPlugin != null)
{
resultCollection.AddRange(vocabularyPlugin.GetValues());
}
}
// GetValuesExtended(string search, string elementName)
return(resultCollection.OrderBy(o => o.Value));
}
public DocumentBuilder(System.Type clazz, Analyzer defaultAnalyzer, IDirectoryProvider[] directoryProviders,
IIndexShardingStrategy shardingStrategy)
{
analyzer = new ScopedAnalyzer();
beanClass = clazz;
this.directoryProviders = directoryProviders;
this.shardingStrategy = shardingStrategy;
if (clazz == null) throw new AssertionFailure("Unable to build a DocumemntBuilder with a null class");
rootPropertiesMetadata = new PropertiesMetadata();
rootPropertiesMetadata.boost = GetBoost(clazz);
rootPropertiesMetadata.analyzer = defaultAnalyzer;
Set<System.Type> processedClasses = new HashedSet<System.Type>();
processedClasses.Add(clazz);
InitializeMembers(clazz, rootPropertiesMetadata, true, string.Empty, processedClasses);
//processedClasses.remove( clazz ); for the sake of completness
analyzer.GlobalAnalyzer = rootPropertiesMetadata.analyzer;
if (idKeywordName == null)
throw new SearchException("No document id for: " + clazz.Name);
}
private static JsiiMethodAttribute GetMethodAttributeCore(System.Type type, string methodName, System.Type[] parameterTypes, BindingFlags bindingFlags)
{
methodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
type = type ?? throw new ArgumentNullException(nameof(type));
parameterTypes = parameterTypes ?? throw new ArgumentNullException(nameof(parameterTypes));
var methodInfo = type.GetMethod(methodName, bindingFlags, null, parameterTypes, Array.Empty <ParameterModifier>());
if (methodInfo == null)
{
throw new ArgumentException($"Method {methodName} does not exist", nameof(methodName));
}
var methodAttribute = methodInfo.GetCustomAttribute <JsiiMethodAttribute>();
if (methodAttribute == null)
{
throw new ArgumentException($"Method {methodName} is missing JsiiMethodAttribute", nameof(methodName));
}
return(methodAttribute);
}
public static TServiceType CreateDecorator <TServiceType>(System.Type decoratorType, bool persistent = false, string name = null) where TServiceType : class, IService
{
var inst = Services.Get <TServiceType>();
if (inst == null)
{
throw new System.InvalidOperationException(string.Format("Must create a concreate service of type {0} before decorating it.", typeof(TServiceType).Name));
}
if (decoratorType == null)
{
throw new System.ArgumentNullException("decoratorType");
}
if (!typeof(TServiceType).IsAssignableFrom(decoratorType))
{
throw new System.ArgumentException("Decorator Type must implement " + typeof(TServiceType).Name);
}
if (!typeof(IServiceDecorator <TServiceType>).IsAssignableFrom(decoratorType))
{
throw new System.ArgumentException("Decorator Type must implement IServiceDecorator");
}
var replacement = CreateUnregisteredService <TServiceType>(decoratorType, persistent, name);
var decorator = replacement as IServiceDecorator <TServiceType>;
if (decorator == null)
{
return(null);
}
Entry <TServiceType> .Instance = replacement;
ReplaceReferences(inst, replacement);
decorator.Consume(inst);
return(replacement);
}
private static JsiiPropertyAttribute GetStaticPropertyAttribute(System.Type type, string propertyName)
{
return(GetPropertyAttributeCore(type, propertyName, StaticMemberFlags));
}
private static JsiiMethodAttribute GetStaticMethodAttribute(System.Type type, string methodName, System.Type[] parameterTypes)
{
return(GetMethodAttributeCore(type, methodName, parameterTypes, StaticMemberFlags));
}
