protected override void Assemble(LayeredCompositeAssembler assembler)
{
assembler
.NewPlainComposite().OfTypes(typeof(TestComposite))
.WithMixins(typeof(TestCompositeMixin)).Done()
.Use(new ModelWideUses());
}
private void AddService(LayeredCompositeAssembler assembler, String serviceID)
{
((ServiceCompositeAssemblyDeclaration)assembler.NewLayeredService()
.VisibleIn(Visibility.MODULE)
.OfTypes(typeof(TestService)))
.SetActivateWithApplication(true)
.Use(serviceID)
;
}
protected override void Assemble(LayeredCompositeAssembler assembler)
{
assembler.NewLayeredService().VisibleIn(Visibility.APPLICATION).OfTypes(typeof(TestService));
var architecture = (LayeredArchitecture)assembler.ApplicationArchitecture;
var serviceLayer = architecture.GetOrCreateLayer(LAYER_NAME);
var midLayer = architecture.GetOrCreateLayer("MidLayer");
var transientLayer = architecture.GetOrCreateLayer("TransientLayer");
transientLayer.GetOrCreateModule("TransientModule").CompositeAssembler.NewPlainComposite().OfTypes(typeof(TestComposite));
transientLayer.UseLayers(midLayer);
midLayer.UseLayers(serviceLayer);
}
protected override void Assemble(LayeredCompositeAssembler assembler)
{
var architecture = (LayeredArchitecture)assembler.ApplicationArchitecture;
var layer1 = architecture.GetOrCreateLayer(LAYER_NAME);
var module1 = layer1.GetOrCreateModule(MODULE_NAME);
var layer2 = architecture.GetOrCreateLayer(LAYER_NAME_2);
var module2 = layer2.GetOrCreateModule(MODULE_NAME);
var layer3 = architecture.GetOrCreateLayer(LAYER_NAME_3);
var module3 = layer3.GetOrCreateModule(MODULE_NAME);
this.AddService(module1.CompositeAssembler, LAYER_NAME);
this.AddService(module2.CompositeAssembler, LAYER_NAME_2);
this.AddService(module3.CompositeAssembler, LAYER_NAME_3);
layer1.UseLayers(layer2);
layer2.UseLayers(layer3);
}
protected override void Assemble(LayeredArchitecture architecture, LayerArchitecture testPerformerLayer, LayeredCompositeAssembler assembler)
{
assembler.NewPlainComposite().OfTypes(typeof(B1Composite)).WithMixins(typeof(BMixin));
}
protected abstract void Assemble(LayeredArchitecture architecture, LayerArchitecture testPerformerLayer, LayeredCompositeAssembler assembler);
protected override void Assemble(LayeredArchitecture architecture, LayerArchitecture testPerformerLayer, LayeredCompositeAssembler assembler)
{
var layer2 = architecture.GetOrCreateLayer(LAYER_2_NAME);
layer2.GetOrCreateModule(MODULE_2_NAME).CompositeAssembler.NewLayeredPlainComposite().VisibleIn(Visibility.LAYER).OfTypes(typeof(B1Composite)).WithMixins(typeof(BMixin));
testPerformerLayer.UseLayers(layer2);
}
protected override void Assemble(LayeredArchitecture architecture, LayerArchitecture testPerformerLayer, LayeredCompositeAssembler assembler)
{
testPerformerLayer.GetOrCreateModule(MODULE_2_NAME).CompositeAssembler.NewPlainComposite().OfTypes(typeof(B1Composite)).WithMixins(typeof(BMixin));
}
protected override void Assemble(LayeredCompositeAssembler assembler)
{
SetupTest(assembler);
}
// TODO implementing value composite model type should be done via extension
//public static LayeredCompositeAssemblyDeclaration ForExistingLayeredValue( this LayeredCompositeAssembler assembler )
//{
// return assembler.ForExistingValue<LayeredCompositeAssemblyDeclaration>();
//}
/// <summary>
/// Helper method to call <see cref="E_Qi4CS.ForExistingService{T}(Assembler)"/> for <see cref="LayeredCompositeAssembler"/> and returning correctly-typed result.
/// </summary>
/// <param name="assembler">The <see cref="LayeredCompositeAssembler"/>-</param>
/// <returns>The result of <see cref="E_Qi4CS.ForExistingService{T}(Assembler)"/> method.</returns>
/// <seealso cref="E_Qi4CS.ForExistingService{T}(Assembler)"/>
public static LayeredServiceCompositeAssemblyDeclaration ForExistingLayeredService(this LayeredCompositeAssembler assembler)
{
return(assembler.ForExistingService <LayeredServiceCompositeAssemblyDeclaration>());
}
/// <summary>
/// Helper method to call <see cref="E_Qi4CS.ForExistingPlainComposite{T}(Assembler)"/> for <see cref="LayeredCompositeAssembler"/> and returning correctly-typed result.
/// </summary>
/// <param name="assembler">The <see cref="LayeredCompositeAssembler"/>-</param>
/// <returns>The result of <see cref="E_Qi4CS.ForExistingPlainComposite{T}(Assembler)"/> method.</returns>
/// <seealso cref="E_Qi4CS.ForExistingPlainComposite{T}(Assembler)"/>
public static LayeredPlainCompositeAssemblyDeclaration ForExistingLayeredPlainComposite(this LayeredCompositeAssembler assembler)
{
return(assembler.ForExistingPlainComposite <LayeredPlainCompositeAssemblyDeclaration>());
}
// TODO implementing value composite model type should be done via extension
//public static LayeredCompositeAssemblyDeclaration NewLayeredValue( this LayeredCompositeAssembler assembler )
//{
// return assembler.NewValue<LayeredCompositeAssemblyDeclaration>();
//}
/// <summary>
/// Helper method to call <see cref="E_Qi4CS.NewService{T}(Assembler)"/> for <see cref="LayeredCompositeAssembler"/> and returning correctly-typed result.
/// </summary>
/// <param name="assembler">The <see cref="LayeredCompositeAssembler"/>-</param>
/// <returns>The result of <see cref="E_Qi4CS.NewService{T}(Assembler)"/> method.</returns>
/// <seealso cref="E_Qi4CS.NewService{T}(Assembler)"/>
public static LayeredServiceCompositeAssemblyDeclaration NewLayeredService(this LayeredCompositeAssembler assembler)
{
return(assembler.NewService <LayeredServiceCompositeAssemblyDeclaration>());
}
/// <summary>
/// Helper method to call <see cref="E_Qi4CS.NewPlainComposite{T}(Assembler)"/> for <see cref="LayeredCompositeAssembler"/> and returning correctly-typed result.
/// </summary>
/// <param name="assembler">The <see cref="LayeredCompositeAssembler"/>-</param>
/// <returns>The result of <see cref="E_Qi4CS.NewPlainComposite{T}(Assembler)"/> method.</returns>
/// <seealso cref="E_Qi4CS.NewPlainComposite{T}(Assembler)"/>
public static LayeredPlainCompositeAssemblyDeclaration NewLayeredPlainComposite(this LayeredCompositeAssembler assembler)
{
return(assembler.NewPlainComposite <LayeredPlainCompositeAssemblyDeclaration>());
}
// TODO implementing value composite model type should be done via extension
//public static Boolean ForNewOrExistingLayeredValue( this Assembler assembler, IEnumerable<Type> types, out LayeredCompositeAssemblyDeclaration result )
//{
// return assembler.ForNewOrExistingValue<LayeredCompositeAssemblyDeclaration>( types, out result );
//}
/// <summary>
/// Helper method to call <see cref="E_Qi4CS.ForNewOrExistingService{T}(Assembler,IEnumerable{System.Type},out T)"/> for <see cref="LayeredServiceCompositeAssemblyDeclaration"/> and returning correctly-typed result.
/// </summary>
/// <param name="assembler">The <see cref="LayeredCompositeAssembler"/>-</param>
/// <param name="types">The composite types.</param>
/// <param name="result">This parameter will hold the resulting composite declaration.</param>
/// <returns>The result of <see cref="E_Qi4CS.ForNewOrExistingService{T}(Assembler,IEnumerable{System.Type},out T)"/> method.</returns>
/// <seealso cref="E_Qi4CS.ForNewOrExistingService{T}(Assembler,IEnumerable{System.Type},out T)"/>
public static Boolean ForNewOrExistingLayeredService(this LayeredCompositeAssembler assembler, IEnumerable <Type> types, out LayeredServiceCompositeAssemblyDeclaration result)
{
return(assembler.ForNewOrExistingService <LayeredServiceCompositeAssemblyDeclaration>(types, out result));
}
protected abstract void Assemble(LayeredCompositeAssembler assembler);
