public SystemsManager( IPluginManager pluginManager, ILogManager logManager, INGinCore core, IMainLoopManager mainLoopManager )
{
this.LogManager = logManager;
foreach ( SystemAttribute plugin in pluginManager.GetPluginsForType( typeof( SystemAttribute ) ) )
{
// create and store system
//ConstructorInfo constructor = plugin.SystemType.GetConstructor( plugin.ConstructorParameterTypes );
//ISystem system = plugin.SystemType.InvokeMember( plugin.SystemType.Name, global::System.Reflection.BindingFlags.CreateInstance, null, null, new object[] { this.LogManager } ) as ISystem;
ISystem system = core.GetService( plugin.SystemType ) as ISystem;
lock ( this.registeredSystemsLock )
{
this.registeredSystems.Add( system.Name, system );
}
}
}
/// <summary>
/// Retrieves all types marked as service and registers them with the builder.
/// </summary>
/// <param name="builder">The autofac builder to register the services with.</param>
/// <param name="pluginManager">The plugin manager to retrieve the service plugin details from.</param>
private void ConfigureServices( ContainerBuilder builder, IPluginManager pluginManager, ILogManager logManager )
{
logManager.Trace( Namespace.LoggerName, LogLevel.Information, "Configuring services..." );
foreach ( Attribute att in pluginManager.GetPluginsForType( typeof( ServiceAttribute ) ) )
{
ServiceAttribute serviceAtt = att as ServiceAttribute;
Type instanceType, interfaceType;
instanceType = serviceAtt.InstanceType;
interfaceType = ( serviceAtt.InterfaceType == null ) ? serviceAtt.InstanceType : serviceAtt.InterfaceType;
if ( serviceAtt.AsSingleton )
{
logManager.Trace( Namespace.LoggerName, LogLevel.Debugging, "Registering service {0} as {1}. Scope: {2}", instanceType.FullName, interfaceType.FullName, "Singleton" );
builder.Register( instanceType ).As( interfaceType ).SingletonScoped();
}
else
{
logManager.Trace( Namespace.LoggerName, LogLevel.Debugging, "Registering service {0} as {1}. Scope: {2}", instanceType.FullName, interfaceType.FullName, "Factory" );
builder.Register( instanceType ).As( interfaceType ).FactoryScoped();
}
}
}
private void ConfigureEntityExtensions( ContainerBuilder builder, IPluginManager pluginManager, ILogManager logManager )
{
logManager.Trace( Namespace.LoggerName, LogLevel.Information, "Configuring entity extensions..." );
try
{
IEnumerable<Attribute> plugins = pluginManager.GetPluginsForType( typeof( EntityExtensionAttribute ) );
foreach ( Attribute att in plugins )
{
EntityExtensionAttribute extAtt = att as EntityExtensionAttribute;
Type instanceType, interfaceType;
instanceType = extAtt.EntityExtensionType;
interfaceType = ( extAtt.InterfaceType == null ) ? extAtt.EntityExtensionType : extAtt.InterfaceType;
logManager.Trace( Namespace.LoggerName, LogLevel.Debugging, "Registering entity extension {0} as {1}.", instanceType.FullName, interfaceType.FullName );
builder.Register( instanceType ).As( interfaceType).FactoryScoped();
}
}
catch ( NGin.Core.Exceptions.PluginNotFoundException )
{
logManager.Trace( Namespace.LoggerName, LogLevel.Error, "No entity extensions registerred." );
}
}
private void ConfigureSystems( ContainerBuilder builder, IPluginManager pluginManager, ILogManager logManager )
{
logManager.Trace( Namespace.LoggerName, LogLevel.Information, "Configuring systems..." );
foreach ( Attribute att in pluginManager.GetPluginsForType( typeof( SystemAttribute ) ) )
{
SystemAttribute systemAtt = att as SystemAttribute;
Type instanceType, interfaceType;
instanceType = systemAtt.SystemType;
interfaceType = ( systemAtt.InterfaceType == null ) ? systemAtt.SystemType : systemAtt.InterfaceType;
logManager.Trace( Namespace.LoggerName, LogLevel.Debugging, "Registering system {0} as {1}.", instanceType.FullName, interfaceType.FullName );
builder.Register( instanceType ).As( interfaceType ).SingletonScoped();
}
}
internal void Initialize( IPluginManager pluginManager, IMachine stateMachine, INGinCore core )
{
// ensure plugin manager is not null
if ( pluginManager == null )
{
string message = "The plugin manager must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "logManager", message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
// ensure state machine is not null
if ( stateMachine == null )
{
string message = "The state machine must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "stateMachine", message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
if ( core == null )
{
string message = "The core must not be null.";
ArgumentNullException argnEx = new ArgumentNullException( "core", message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, argnEx, message );
throw argnEx;
}
IEnumerable<Attribute> statePlugins = pluginManager.GetPluginsForType( typeof( NGinRootStateAttribute ) );
// ensure that only one root state is defined
if ( statePlugins.Count<Attribute>() > 1 )
{
string message = "More than one root state plugin was found. There must be only 1.";
InvalidOperationException invOpEx = new InvalidOperationException( message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, invOpEx, message );
throw invOpEx;
}
// get attribute
NGinRootStateAttribute rootStateAtt = statePlugins.ElementAt<Attribute>( 0 ) as NGinRootStateAttribute;
// make sure attribute is not null
if ( rootStateAtt == null )
{
string message = "Error loading the root state plugin.";
InvalidOperationException invOpEx = new InvalidOperationException( message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, invOpEx, message );
throw invOpEx;
}
// add type to machine root
Type rootStateType = rootStateAtt.RootStateType;
IState state = core.GetService( rootStateType ) as IState;
if ( state == null )
{
string message = String.Format( System.Globalization.CultureInfo.InvariantCulture, "An error occurred while retrieving instance of {0}.", rootStateType.FullName );
InvalidOperationException invopEx = new InvalidOperationException( message );
this.LogManager.Trace( Namespace.LoggerName, LogLevel.Error, invopEx, message );
throw invopEx;
}
this.StateMachine.RootState.AddSubState( state );
stateMachine.Initialize( state.Name );
}
