Merge pull request #177 from JacopoWolf/dev/4

Dev/4

Author: JacopoWolf

StackInjector/Core/IStackWrapperCore.cs

@@ -24,10 +24,9 @@ public interface IStackWrapperCore : IDisposable, ICloneableCore
 		/// <typeparam name="T"></typeparam>
 		IEnumerable<T> GetServices<T> ();
 
-		//! description is wrong
 		/// <summary>
 		/// The current number of all tracked services.<br/>
-		/// Does also include the Wrapper, so if you want all the instances 
+		/// Does also include the Wrapper, so if you want just the instances 
 		/// <c>wrapper.CountServices()-1</c>
 		/// </summary>
 		int CountServices ();

StackInjector/Core/InjectionCore/InjectionCore.instantiation.cs

@@ -17,9 +17,6 @@ private object OfTypeOrInstantiate ( Type type )
 			if ( serviceAtt == null )
 				throw new NotAServiceException(type, $"Type {type.FullName} is not a [Service]");
 
-			////if( !this.instances.ContainsKey(type) )
-			////	throw new ServiceNotFoundException(type, $"The type {type.FullName} is not in a registred assembly!");
-
 
 			return serviceAtt.Pattern switch
 			{

StackInjector/Core/InjectionCore/InjectionCore.reflection.cs

@@ -14,41 +14,34 @@ private Type ClassOrVersionFromInterface ( Type type, ServedAttribute servedAttr
 		{
 			if ( type.IsInterface )
 			{
-				IEnumerable<Type> versions = this.instances.TypesAssignableFrom(type);
+				IEnumerable<Type> versions = this.Version(type, servedAttribute);
 
-				// is there already an implementation for the interface?
 				if ( versions.Any() )
 				{
-					return versions.First();
+					//todo check for multiple valid versions
+					var t = versions.First();
+					MaskPass(t);
+					return t;
 				}
+
+				if ( servedAttribute is null )
+					throw new ImplementationNotFoundException(type, $"can't find [Service] for interface {type.Name}");
 				else
-				{
-					versions = this.Version(type, servedAttribute);
-					if ( versions.Any() )
-					{
-						var t = versions.First();
-						MaskPass(t);
-						return t;
-					}
-
-					if ( servedAttribute is null )
-						throw new ImplementationNotFoundException(type, $"can't find [Service] for interface {type.Name}");
-					else
-						throw new ImplementationNotFoundException(type, $"can't find [Service] for {type.Name} v{servedAttribute.TargetVersion}");
-				}
+					throw new ImplementationNotFoundException(type, $"can't find [Service] for {type.Name} v{servedAttribute.TargetVersion}");
+				
 			}
 			else
 			{
 				MaskPass(type);
 				return type;
 			}
 
-
+			// exception check and thrower
 			void MaskPass ( Type type )
 			{
-				if ( this.settings.Mask.IsMasked(type) )
+				if ( this.settings.Mask.IsMasked(type) ) //todo create custom exception
 					throw new InvalidOperationException($"Type {type.Name} is { (this.settings.Mask._isWhiteList ? "not whitelisted" : "blacklisted")}");
-				//todo create custom exception
+
 			}
 
 

StackInjector/Core/InjectionCore/InjectionCore.versioning.cs

@@ -9,22 +9,40 @@ namespace StackInjector.Core
 {
 	internal partial class InjectionCore
 	{
+		private static readonly Type _istackwrappercore = typeof(IStackWrapperCore);
+
 		// performs versioning on the specified type
 		private IEnumerable<Type> Version ( Type targetType, ServedAttribute servedAttribute )
 		{
+			if (targetType.IsSubclassOf( _istackwrappercore ) || targetType == _istackwrappercore)
+				return this.instances.TypesAssignableFrom(targetType);
+
+			if (this.settings.Versioning._customBindings != null &&
+				this.settings.Versioning._customBindings.TryGetValue(targetType,out var t) )
+			{
+				return Enumerable.Repeat(t, 1);
+			}
+			
 
 			var targetVersion = servedAttribute?.TargetVersion ?? 0.0;
 			var method =
-				(this.settings.Injection._overrideTargetingMethod || servedAttribute is null || !(servedAttribute._targetingDefined))
-					? this.settings.Injection._targetingMethod
+				(this.settings.Versioning._overrideTargetingMethod || servedAttribute is null || !(servedAttribute._targetingDefined))
+					? this.settings.Versioning._targetingMethod
 					: servedAttribute.TargetingMethod;
 
-
-			////var candidateTypes = this.instances.TypesAssignableFrom(targetType);
-			var candidateTypes = targetType
-				.Assembly
-				.GetTypes()
-				.Where( t => t.IsClass && !t.IsAbstract && targetType.IsAssignableFrom(t));
+			IEnumerable<TypeInfo> candidateTypes =
+				(this.settings.Versioning.AssemblyLookUpOrder.Any())
+				?
+				this.settings.Versioning
+					.AssemblyLookUpOrder
+					.SelectMany( a => a.DefinedTypes )
+					.Where( t => t.IsClass && !t.IsAbstract
+						&& targetType.IsAssignableFrom(t) && !this.settings.Mask.IsMasked(t) )
+				:
+				targetType
+					.Assembly
+					.DefinedTypes
+					.Where( t => t.IsClass && !t.IsAbstract && targetType.IsAssignableFrom(t) );
 
 
 			return method switch

StackInjector/Core/InstancesHolder.cs

@@ -27,11 +27,12 @@ internal bool AddType ( Type type )
 			return this.TryAdd(type, new LinkedList<object>());
 		}
 
-		internal void CountAllInstances ()
+		internal int CountAllInstances ()
 		{
 			this.total_count = 0;
 			foreach ( var pair in this )
 				this.total_count += pair.Value.Count;
+			return this.total_count;
 		}
 
 

StackInjector/Core/StackWrapperCore.cs

@@ -26,7 +26,7 @@ public StackWrapperCore ( InjectionCore core, Type toRegister )
 			if ( !this.Core.instances.AddType(toRegister) )
 				this.Core.instances[toRegister].Clear();
 			this.Core.instances[toRegister].AddFirst(this);
-			
+
 		}
 
 
@@ -38,8 +38,10 @@ public IEnumerable<T> GetServices<T> ()
 				.Select(o => (T)o);
 		}
 
-		public int CountServices () => this.Core.instances.total_count;
-
+		public int CountServices ()
+		{
+			return this.Core.instances.CountAllInstances();
+		}
 
 		public IClonedCore CloneCore ( StackWrapperSettings settings = null )
 		{

StackInjector/Settings/InjectionOptions.cs

@@ -5,12 +5,10 @@ namespace StackInjector.Settings
 {
 
 	/// <summary>
-	/// Options for the injection process.
+	/// Options for the injection process, regarding HOW the inejction should be performed
 	/// </summary>
 	public sealed class InjectionOptions : IOptions
 	{
-		internal ServedVersionTargetingMethod       _targetingMethod                        = ServedVersionTargetingMethod.None;
-		internal bool                               _overrideTargetingMethod;
 
 		internal ServingMethods                     _servingMethod                          = StackWrapperSettings.ServeAllStrict;
 		internal bool                               _overrideServingMethod;
@@ -42,10 +40,7 @@ public object Clone ()
 		/// <summary>
 		/// The default injection. Settings are valorized as following:
 		/// <list type="table">
-		/// <item>
-		///		<term><see cref="VersioningMethod(ServedVersionTargetingMethod, bool)"/></term>
-		///		<description><see cref="ServedVersionTargetingMethod.None"/>, false</description>
-		///	</item><item>
+		///	<item>
 		///		<term><see cref="ServingMethod(ServingMethods, bool)"/></term><description>
 		///		<see cref="StackWrapperSettings.ServeAllStrict"/>, false</description>
 		///	</item><item>
@@ -82,20 +77,6 @@ public InjectionOptions TrackInstantiationDiff ( bool track = true, bool callDis
 			return this;
 		}
 
-
-		/// <summary>
-		/// Overrides default targetting method
-		/// </summary>
-		/// <param name="targetMethod">the new default targetting method</param>
-		/// <param name="override">if true, versioning methods for [Served] fields and properties are overriden</param>
-		/// <returns>the modified settings</returns>
-		public InjectionOptions VersioningMethod ( ServedVersionTargetingMethod targetMethod, bool @override = false )
-		{
-			this._targetingMethod = targetMethod;
-			this._overrideTargetingMethod = @override;
-			return this;
-		}
-
 		/// <summary>
 		/// Overrides default serving method
 		/// </summary>

StackInjector/Settings/MaskOptions.cs

@@ -50,8 +50,8 @@ public bool IsMasked ( Type type )
 		{
 			if ( _isDisabled )
 				return false;
-			else
-				return this._isWhiteList ^ this.Contains(type); //.XOR
+
+			return this._isWhiteList ^ this.Contains(type); //.XOR
 
 		}
 
@@ -68,7 +68,7 @@ public object Clone ()
 		public static MaskOptions WhiteList => new MaskOptions() { _isWhiteList = true };
 
 		/// <summary>
-		/// allow every type <b>except</b> the regisred ones.
+		/// allow every type <b>except</b> the registred ones.
 		/// </summary>
 		public static MaskOptions BlackList => new MaskOptions();
 

StackInjector/Settings/StackWrapperSettings.cs

@@ -18,13 +18,19 @@ public sealed partial class StackWrapperSettings
 		/// </summary>
 		public InjectionOptions Injection { get; private set; }
 
+		/// <summary>
+		/// manages versioning options.
+		/// </summary>
+		public VersioningOptions Versioning { get; private set; }
+
 		/// <summary>
 		/// manages runtime options
 		/// </summary>
 		public RuntimeOptions Runtime { get; private set; }
 
 
 
+
 		private StackWrapperSettings () { }
 
 
@@ -38,7 +44,8 @@ public StackWrapperSettings Clone ()
 			return With(
 				(InjectionOptions)this.Injection.Clone(),
 				(RuntimeOptions)this.Runtime.Clone(),
-				(MaskOptions)this.Mask.Clone()
+				(MaskOptions)this.Mask.Clone(),
+				(VersioningOptions)this.Versioning.Clone()
 				);
 		}
 
@@ -48,6 +55,7 @@ public StackWrapperSettings Clone ()
 		/// <seealso cref="InjectionOptions.Default"/>,
 		/// <seealso cref="RuntimeOptions.Default"/>,
 		/// <seealso cref="MaskOptions.Disabled"/>
+		/// <seealso cref="VersioningOptions.Default"/>
 		/// </summary>
 		public static StackWrapperSettings Default => With();
 
@@ -58,14 +66,18 @@ public StackWrapperSettings Clone ()
 		/// <param name="injection">the injection options</param>
 		/// <param name="runtime">the runtime options</param>
 		/// <param name="mask">mask options</param>
+		/// <param name="versioning">versioning options</param>
 		/// <returns></returns>
-		public static StackWrapperSettings With ( InjectionOptions injection = null, RuntimeOptions runtime = null, MaskOptions mask = null )
+		public static StackWrapperSettings With (
+			InjectionOptions injection = null, RuntimeOptions runtime = null,
+			MaskOptions mask = null, VersioningOptions versioning = null )
 		{
 			return new StackWrapperSettings()
 			{
 				Mask = mask ?? MaskOptions.Disabled,
 				Injection = injection ?? InjectionOptions.Default,
-				Runtime = runtime ?? RuntimeOptions.Default
+				Runtime = runtime ?? RuntimeOptions.Default,
+				Versioning = versioning ?? VersioningOptions.Default
 			};
 		}
 
@@ -83,8 +95,10 @@ public static StackWrapperSettings With ( InjectionOptions injection = null, Run
 				mask:
 					null,
 				runtime:
+					null,
+				versioning:
 					null
-				);
+			);
 
 
 	}