public static List <object> GetInstances(Type InterfaceType) { string name = InterfaceType.Name; if (!Instances.ContainsKey(name)) { lock (_lock) { if (!Instances.ContainsKey(name)) { List <object> Result = new List <object>(); var types = GetImplementationTypes(InterfaceType); foreach (var item in types) { var instance = Activator.CreateInstance(item); if (instance != null) { Result.Add(instance); } } Instances[name] = Result; } } } return(Instances[name]); }
public static bool Load(UInt32 id, UInt32 characterID, ModelType model_type, string name, Vector3 position) { if (Instances.Count() >= Max) { return(false); } if (Instances.ContainsKey(id)) { return(false); } GameObject prefab; if (ObjectManager.PlayerModels.TryGetValue(model_type, out prefab)) { var character = UnityEngine.Object.Instantiate(ObjectManager.PlayerModels[model_type]) .AddComponent <Character>() .Initialize <ClientActor>(characterID, name); character.transform.position = position; Instances[id] = new Client(id, character); } return(true); }
/// <summary> /// Indicates whether or not an instance was cached by the specified keys. /// </summary> /// <param name="successful"> /// Was the check successful (e.g., wouldn't be successful if the lock /// timeout expired). /// </param> /// <param name="keys"> /// Optional. The keys to store/retrieve a value by. Each key combination will /// be treated as a separate cache. /// </param> /// <returns> /// True, if an item was cached by the specified keys; otherwise, false. /// </returns> public bool WasCached(out bool successful, params string[] keys) { var lockTaken = default(bool); try { Monitor.TryEnter(InstanceLock, LockTimeout, ref lockTaken); if (lockTaken) { successful = true; return(LastCache.HasValue ? Instances.ContainsKey(keys) : false); } else { CacheSettings.FailedLockHandler(LockTimeout); successful = false; return(false); } } finally { if (lockTaken) { Monitor.Exit(InstanceLock); } } }
/// <summary> /// Enregistre une usine de fabrication d'instance d'une interface /// <para> /// L'usine sera utilisée lors de la première récupération de l'interface. /// Si une usine est déjà enregistrée pour cette interface, celle-ci est remplacée. /// </para> /// </summary> /// <remarks></remarks> /// <typeparam name="TInterface">Interface</typeparam> /// <typeparam name="TInstance">Instance de l'interface</typeparam> /// <param name="factory">Usine de fabrication</param> /// <exception cref="ArgumentNullException"></exception> public void RegisterFactory <TInterface, TInstance>(Func <TInstance> factory) where TInstance : class, TInterface, new() { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } lock (Locker) { var interfaceType = typeof(TInterface); if (Instances.ContainsKey(interfaceType)) { Factories[interfaceType] = factory; _logger.Debug($"Usine de [{interfaceType}] remplacée."); } else { Instances.Add(interfaceType, null); Factories.Add(interfaceType, factory); _logger.Debug($"Usine de [{interfaceType}] enregistrée."); } } }
/// <summary> /// Gets an instance of the configuration for a given publication /// </summary> /// <param name="publication"></param> /// <returns></returns> public static TridionConfigurationManager GetInstance(Publication publication) { log.Debug(">>GetInstance called for " + publication.Id); // locking to make threadsafe // this prevents errors like 'given key was not present in the dictionary' lock (lock1) { if (!Instances.ContainsKey(publication.Id)) { log.Debug("no instance found, creating new one"); AddInstance(publication); } else { log.Debug(string.Format("found instance, publication revision date {0}, config file modification date {1}, cache date {2}", publication.RevisionDate, ConfigurationModificationDate, InstanceCacheDates[publication.Id])); if (InstanceCacheDates[publication.Id].CompareTo(publication.RevisionDate) < 0 || InstanceCacheDatesFS[publication.Id].CompareTo(ConfigurationModificationDate) < 0) { log.Debug("creating new instance"); RemoveInstance(publication); AddInstance(publication); } } } return(Instances[publication.Id]); }
internal static Tweaker Lookup(string hostname) { if (!Instances.ContainsKey(hostname)) { Instances[hostname] = new Tweaker(hostname); } return(Instances[hostname]); }
public static uSplitAuthorizationCodeFlow GetInstance(AccountConfig config) { if (!Instances.ContainsKey(config.UniqueId)) { Instances[config.UniqueId] = new uSplitAuthorizationCodeFlow(config); } return(Instances[config.UniqueId]); }
public object Resolve(Type type) { if (Instances.ContainsKey(type)) { return(Instances[type]); } throw new ArgumentException("unregistered dependency"); }
public static S Instance(string name) { if (!Instances.ContainsKey(name)) { throw new UndefinedNameError(name); } return(Instances[name]); }
public void AddInstances(GlobalGeometryPartBlockNew part, IEnumerable <Matrix4> instanceWorldMatrices) { if (!Instances.ContainsKey(part)) { Instances[part] = new List <Matrix4>(instanceWorldMatrices); return; } Instances[part].AddRange(instanceWorldMatrices); }
public void RegisterInstance(Type service, object implementation) { if (!Instances.ContainsKey(service)) { Instances.Add(service, new List <object> { implementation }); } }
public static FormulaStringFx GetInstance(string formatString) { if (!Instances.ContainsKey(formatString)) { Instances[formatString] = new FormulaStringFx(formatString); } return(Instances[formatString]); }
public void AddActivation(ActivationId act, SiloAddress silo) { if (SingleInstance && (Instances.Count > 0) && !Instances.ContainsKey(act)) { throw new InvalidOperationException( "Attempting to add a second activation to an existing grain in single activation mode"); } Instances[act] = new ActivationInfo(silo); VersionTag = rand.Next(); }
/// <summary> /// Sets the autostart instance in the registry and saves it. /// </summary> public static void SetAutoStart(string name) { if (!Instances.ContainsKey(name)) { throw new InvalidKSPInstanceKraken(name); } _AutoStartInstance = name; PopulateRegistryWithInstances(); }
/// <summary> /// Sets the current instance. /// Throws an InvalidKSPInstanceKraken if not found. /// </summary> public static void SetCurrentInstance(string name) { // TODO: Should we disallow this if _CurrentInstance is already set? if (!Instances.ContainsKey(name)) { throw new InvalidKSPInstanceKraken(name); } _CurrentInstance = Instances[name]; }
public static Printer Get(Subsystem ss) { if (Instances.ContainsKey(ss)) { return(Instances[ss]); } var instance = new Printer(); Instances[ss] = instance; return(instance); }
public void RegisterLazy(Type service, Func <object> factory) { if (factory is null) { throw new ArgumentNullException(nameof(factory)); } if (!Instances.ContainsKey(service)) { Instances.Add(service, new List <object> { factory() }); } }
public static bool InitializeInstance(Type rInterfaceType, IInterface rInterface) { if (!rInterfaceType.IsInterface) { return(false); } if (Instances.ContainsKey(rInterfaceType)) { return(false); } Instances[rInterfaceType] = rInterface; return(true); }
public Dictionary <SiloAddress, List <ActivationAddress> > Merge(GrainId grain, IGrainInfo other) { bool modified = false; foreach (var pair in other.Instances) { if (Instances.ContainsKey(pair.Key)) { continue; } Instances[pair.Key] = new ActivationInfo(pair.Value.SiloAddress, pair.Value.RegistrationStatus); modified = true; } if (modified) { VersionTag = rand.Next(); } if (SingleInstance && (Instances.Count > 0)) { // Grain is supposed to be in single activation mode, but we have two activations!! // Eventually we should somehow delegate handling this to the silo, but for now, we'll arbitrarily pick one value. var orderedActivations = Instances.OrderBy(pair => pair.Key); var activationToKeep = orderedActivations.First(); var activationsToDrop = orderedActivations.Skip(1); Instances.Clear(); Instances.Add(activationToKeep.Key, activationToKeep.Value); var mapping = new Dictionary <SiloAddress, List <ActivationAddress> >(); foreach (var activationPair in activationsToDrop) { var activation = ActivationAddress.GetAddress(activationPair.Value.SiloAddress, grain, activationPair.Key); List <ActivationAddress> activationsToRemoveOnSilo; if (!mapping.TryGetValue(activation.Silo, out activationsToRemoveOnSilo)) { activationsToRemoveOnSilo = mapping[activation.Silo] = new List <ActivationAddress>(1); } activationsToRemoveOnSilo.Add(activation); } return(mapping); } return(null); }
public static ICrawler CreateMine(string url) { ICrawler result = null; string name = "{0}"._Format(DefaultConfiguration.GetAppSetting("ApplicationName", "UNKNOWN")); if (Instances.ContainsKey(name)) { result = Instances[name]; } else { result = Create(name, url); } return(result); }
// Actual worker for GetPreferredInstance() internal static KSP _GetPreferredInstance() { // First check if we're part of a portable install // Note that this *does not* register in the registry. string path = KSP.PortableDir(); if (path != null) { return(new KSP(path)); } // Return the autostart, if we can find it. if (AutoStartInstance != null) { // We check both null and "" as we can't write NULL to the registry, so we write an empty string instead // This is neccessary so we can indicate that the user wants to reset the current AutoStartInstance without clearing the windows registry keys! if (AutoStartInstance == "") { return(null); } if (Instances.ContainsKey(AutoStartInstance)) { return(Instances[AutoStartInstance]); } } // If we only know of a single instance, return that. if (Instances.Count == 1) { // Surely there's a better way to get the singleton value than this? var keys = new List <string>(Instances.Keys); return(Instances[keys[0]]); } // If we know of no instances, try to find one. if (Instances.Count == 0) { return(FindAndRegisterDefaultInstance()); } // Otherwise, we know of too many instances! // We don't know which one to pick, so we return null. return(null); }
public bool Merge(GrainId grain, IGrainInfo other) { bool modified = false; foreach (var pair in other.Instances) { if (Instances.ContainsKey(pair.Key)) { continue; } Instances[pair.Key] = new ActivationInfo(pair.Value.SiloAddress); modified = true; } if (modified) { VersionTag = rand.Next(); } if (SingleInstance && (Instances.Count > 0)) { // Grain is supposed to be in single activation mode, but we have two activations!! // Eventually we should somehow delegate handling this to the silo, but for now, we'll arbitrarily pick one value. var orderedActivations = Instances.OrderBy(pair => pair.Key); var activationToKeep = orderedActivations.First(); var activationsToDrop = orderedActivations.Skip(1); Instances.Clear(); Instances.Add(activationToKeep.Key, activationToKeep.Value); var list = new List <ActivationAddress>(1); foreach (var activation in activationsToDrop.Select(keyValuePair => ActivationAddress.GetAddress(keyValuePair.Value.SiloAddress, grain, keyValuePair.Key))) { list.Add(activation); CatalogFactory.GetSystemTarget(Constants.CatalogId, activation.Silo). DeleteActivations(list).Ignore(); list.Clear(); } return(true); } return(false); }
public void AddVariable <T>(string name, T obj, int recursionLevel) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (obj == null) { throw new ArgumentNullException(nameof(obj)); } if (recursionLevel < 0) { throw new ArgumentOutOfRangeException(nameof(recursionLevel), "Recursion level must be positive."); } if (Instances.ContainsKey(name)) { throw new InvalidOperationException("Variable with the name " + name + " already exists."); } Type type = typeof(T); if (!type.IsPublic) { throw new InvalidOperationException("Only variables of public type can be added."); } ((IDictionary <string, object>)_interpreter.Globals.globals).Add(name, obj); // Add instance. Instances.Add(name, new Member { Name = name, Type = type }); InstancesAndStaticsDirty = true; if (InstanceMembers.ContainsKey(type)) { return; } AddTypeImpl(type, recursionLevel); }
public bool AddActivation(ActivationId act, SiloAddress silo) { if (SingleInstance && (Instances.Count > 0) && !Instances.ContainsKey(act)) { throw new InvalidOperationException( "Attempting to add a second activation to an existing grain in single activation mode"); } IActivationInfo info; if (Instances.TryGetValue(act, out info)) { if (info.SiloAddress.Equals(silo)) { // just refresh, no need to generate new VersionTag return(false); } } Instances[act] = new ActivationInfo(silo, MultiClusterStatus.Owned); VersionTag = rand.Next(); return(true); }
/// <summary> /// Récupère l'instance d'une interface /// <para> /// Renvoie <c>null</c> si l'interface est introuvable. /// </para> /// </summary> /// <typeparam name="TInterface">Type de l'interface</typeparam> /// <returns>Instance de l'interface</returns> public TInterface GetInstance <TInterface>() { lock (Locker) { var type = typeof(TInterface); if (!Instances.ContainsKey(type)) { _logger.Warn($"Interface introuvable : [{type}]."); return(default(TInterface)); } var instance = Instances[type]; if (instance == null) { return(CreateInstance <TInterface>()); } return((TInterface)Instances[type]); } }
/// <summary> /// Saves the instance. /// </summary> /// <typeparam name="TInterface">The type of the interface.</typeparam> /// <typeparam name="TInstance">The type of the instance.</typeparam> /// <param name="instance">The instance.</param> private void SaveInstance <TInterface, TInstance>(TInstance instance) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } lock (Locker) { var interfaceType = typeof(TInterface); if (Instances.ContainsKey(interfaceType)) { Instances[interfaceType] = instance; _logger.Debug($"Instance de [{interfaceType}] remplacée."); } else { Instances.Add(interfaceType, instance); _logger.Debug($"Instance de [{interfaceType}] enregistrée."); } } }
private static FileDownloader DoGetInstance(Type type) { if (type == null) { throw new ArgumentException("Invalid arguments to get file downloader instance"); } var key = type.FullName + "_"; FileDownloader instance = null; if (Instances.ContainsKey(key)) { instance = Instances[key]; } if (instance == null) { Logger.GetInstance(typeof(FileDownloader)).Info("Initializing " + key + "..."); var constructor = type.GetConstructor(new Type[] { }); if (constructor != null) { instance = (FileDownloader)constructor.Invoke(new object[] { }); } } if (instance == null) { Logger.GetInstance(typeof(FileDownloader)).Info("Initializing " + typeof(HttpFileDownloader).FullName + "..."); instance = new HttpFileDownloader(); } lock (InstanceLock) { if (!Instances.ContainsKey(key)) { Instances.Add(key, instance); } } return(instance); }
public Object this[String instanceName] { get { if (Instances.ContainsKey(instanceName)) { return(Instances[instanceName]); } else { return(null); } } set { if (Instances.ContainsKey(instanceName)) { Instances.Remove(instanceName); } Instances.Add(instanceName, value); } }
public static ICrawler Create(string name, string url) { lock (_createLock) { ImageCrawler crawler = new ImageCrawler(); crawler.Name = name; crawler.Root = url; if (Instances.ContainsKey(name)) { Instances[name] = crawler; } else { Instances.Add(crawler.Name, crawler); } ImageCrawler.EnsureOne(crawler); return(crawler); } }
private static Logger DoGetInstance(Type type, string name) { if (type == null || name == null) { throw new ArgumentException("Invalid arguments to get logger instance"); } var key = type.FullName + "_" + name; Logger instance = null; if (Instances.ContainsKey(key)) { instance = Instances[key]; } if (instance == null) { Console.Error.WriteLine("Initializing " + key + "..."); var constructor = type.GetConstructor(new[] { typeof(string) }); if (constructor != null) { instance = (Logger)constructor.Invoke(new object[] { name }); } } if (instance == null) { Console.Error.WriteLine("Initializing " + typeof(ConsoleLogger).FullName + "[" + name + "]..."); instance = new ConsoleLogger(name); } lock (InstancesLock) { if (!Instances.ContainsKey(key)) { Instances.Add(key, instance); } } return(instance); }