private LifetimeScope()
{
this._synchRoot = new object();
this._sharedInstances = new Dictionary <Guid, object>();
this._disposer = new Autofac.Core.Disposer();
this._sharedInstances[SelfRegistrationId] = this;
}
protected internal ServiceDescription(IDisposer disposer, Root root)
: base(root)
{
if (disposer == null) throw new ArgumentNullException ("disposer");
this.disposer = disposer;
}
protected static void AssignDisposer(BaseDeferred deferred, IDisposer disposer)
{
if (disposer != null)
{
deferred.Disposer = disposer;
deferred.Disposer.Add(deferred.ClearCallbacks);
}
}
public PreparationUnitController(IPreparationUnitModel model, PreparationUnitView view,
[Inject(Id = PlayArea.Board)] IPlayAreaService boardService, [Inject(Id = PlayArea.Bench)] IPlayAreaService benchService,
IDisposer disposer)
{
_view = view;
_boardService = boardService;
_benchService = benchService;
model.Position.Subscribe(pos => SetPosition(pos, model.IsOnBoard)).AddToDisposer(disposer);
}
protected internal DeviceDescription(IDisposer disposer, Root root)
: base(root)
{
if (disposer == null)
{
throw new ArgumentNullException("disposer");
}
this.disposer = disposer;
}
private ShopUnitController(IShopUnitModel unitModel, IShopUnitView unitView, IDisposer disposer)
{
unitModel.CanBeBought
.Subscribe(purchasable => unitView.Purchasable = purchasable)
.AddToDisposer(disposer);
unitView.BuyButton.OnClickAsObservable()
.Where(_ => unitModel.CanBeBought.Value)
.Subscribe(_ => unitModel.Buy())
.AddToDisposer(disposer);
}
public IPromise AddDisposer(IDisposer disposer)
{
var deferred = new Deferred();
AssignDisposer(deferred, disposer);
Done(() => deferred.Resolve());
Fail(() => deferred.Reject());
return(deferred);
}
protected internal DeviceDescription(Root root, IDisposer disposer)
: base(root)
{
if (disposer == null)
{
throw new ArgumentNullException("disposer");
}
this.disposer = disposer;
services = new ProtectedCollection <ServiceDescription> ();
devices = new ProtectedCollection <DeviceDescription> ();
icons = new ProtectedCollection <IconDescription> ();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="objectFactory">Factory for creating new objects.</param>
/// <param name="unusedObjectStore">Cache for the unused objects.</param>
/// <param name="usedObjectStore">Cache for the used objects.</param>
/// <param name="objectDisposer">Optional disposer for objects which are no longer needed.</param>
/// <param name="maximumObjects">The maximum number of objects that can be created in the pool.</param>
public BasePooler(
IFactory <TPooledObject> objectFactory,
IStore <TPooledObject> unusedObjectStore,
IStore <TPooledObject> usedObjectStore,
IDisposer <TPooledObject> objectDisposer = null,
int maximumObjects = int.MaxValue)
{
ObjectFactory = objectFactory;
UnusedObjectStore = unusedObjectStore;
UsedObjectStore = usedObjectStore;
ObjectDisposer = objectDisposer;
MaximumObjects = maximumObjects;
}
protected BaseRealTimeLogicGate([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IEnumerable <IWire> wiresIn,
[NotNull] IEnumerable <IWire> wiresOut)
{
m_Disposer = disposer;
m_Agenda = agenda;
Inputs = wiresIn;
Outputs = wiresOut;
SignalChangedHandlersSubscribe();
m_Disposer.AddResource(SignalChangedHandlersUnsubscribe);
}
protected virtual ServiceDescription DeserializeServiceCore(IDisposer disposer, XmlReader reader)
{
try {
var service = CreateService(disposer);
if (service != null)
{
service.Deserialize(this, reader);
}
return(service);
} catch (Exception e) {
Log.Exception("There was a problem deserializing a service.", e);
return(null);
}
}
public TestLogicGate([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IWire wireIn,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireIn
},
new[]
{
wireOut
})
{
}
public RealTimeProbe([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IWire wire,
[NotNull] IProbeFactory factory)
: base(disposer,
agenda,
new[]
{
wire
},
new[]
{
wire
})
{
m_Probe = factory.Create(wire);
}
/// <summary>
/// Constructeur
/// </summary>
protected ViewModelBase()
{
_disposer = new Disposer();
if (!IsInDesignMode)
{
this.TraceDebug("{0}.ctor()", GetType());
}
_viewModelState = ViewModelStateEnum.Inactive;
if (!IsInDesignMode)
{
Initialize();
}
InitializeDesigner();
}
public RealTimeInverter([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IInverterFactory factory,
[NotNull] IWire wireIn,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireIn
},
new[]
{
wireOut
})
{
m_Inverter = factory.Create(wireIn,
wireOut);
}
public RealTimeOr([NotNull] IDisposer disposer,
[NotNull] IAgenda agenda,
[NotNull] IOrFactory factory,
[NotNull] IWire wireInOne,
[NotNull] IWire wireInTwo,
[NotNull] IWire wireOut)
: base(disposer,
agenda,
new[]
{
wireInOne,
wireInTwo
},
new[]
{
wireOut
})
{
m_Or = factory.Create(wireInOne,
wireInTwo,
wireOut);
}
protected virtual DeviceDescription CreateDevice(IDisposer disposer)
{
return new DeviceDescription (disposer);
}
protected virtual ServiceDescription CreateService(IDisposer disposer)
{
return new ServiceDescription (disposer);
}
protected virtual ServiceDescription CreateService(IDisposer disposer)
{
return(new ServiceDescription(disposer));
}
/// <summary>
/// Permet de disposer un IDisposable avec un disposer
/// </summary>
/// <typeparam name="TDisposable">type de disposable</typeparam>
/// <param name="disposable">disposable à associer</param>
/// <param name="disposer">disposer à associer</param>
/// <returns>l'instance du disposable</returns>
public static TDisposable DisposeWith <TDisposable>(this TDisposable disposable, IDisposer disposer)
where TDisposable : IDisposable
{
disposer.Register(disposable);
return(disposable);
}
public ShopUnitModel(int initialId, ICashModel cashModel, IBenchPreparationUnitPool benchPreparationUnitPool,
IPreparationUnitFactory preparationUnitFactory, IShopConfig shopConfig, IDisposer disposer)
{
_id = new ReactiveProperty <int>(initialId);
_hasBeenBought = new ReactiveProperty <bool>(false);
Cost = _id.Select(shopConfig.GetCost)
.ToReadOnlyReactiveProperty()
.AddToDisposer(disposer);
_cashModel = cashModel;
_preparationUnitFactory = preparationUnitFactory;
CanBeBought = benchPreparationUnitPool.IsBenchFull
.CombineLatest(cashModel.CurrentCash, Cost, _hasBeenBought,
(benchFull, cash, cost, purchased) => !benchFull && cash >= cost && !purchased)
.ToReadOnlyReactiveProperty()
.AddToDisposer(disposer);
}
/// <summary>
/// Creates new instance of reference counting wrapper for given object.
/// To end the lifecycle of the object the given disposer will be used.
/// This class should not be used directly, only via SharedHandle instances
/// </summary>
/// <param name="obj">The object to wrap</param>
/// <param name="disposer">The disposer to use for the object</param>
internal SharedDisposableObject(TType obj, IDisposer <TType> disposer)
{
referent = obj;
this.disposer = disposer;
refCount = 0;
}
public ShopPanelController(IShopPanelView view, IShopConfig config, IShopFactory factory,
IUnitPool <IShopUnitModel> shopPool, IRandomUnitGenerator unitGenerator, IEventBus eventBus, IDisposer disposer)
{
_eventBus = eventBus;
view.CloseButton.OnClickAsObservable()
.Merge(view.BackgroundButton.OnClickAsObservable())
.SubscribeBlind(() => ClosePanel(view))
.AddToDisposer(disposer);
// open panel on event
eventBus.OnEvent <OpenShopCommand>().SubscribeBlind(view.Open).AddToDisposer(disposer);
// only spawn items once shop is first opened
AddShopUnits(config.ShopEntryAmount, view, shopPool, factory, unitGenerator);
}
public HudShopController(HudView hudView, IEventBus eventBus, IDisposer disposer)
{
hudView.ShopButton.OnClickAsObservable()
.SubscribeBlind(() => eventBus.Publish(new OpenShopCommand()))
.AddToDisposer(disposer);
}
public static T AddToDisposer <T>(this T disposable, IDisposer disposer) where T : IDisposable
{
disposer.Add(disposable);
return(disposable);
}
private void Inject([InjectLocal] IDisposer disposer)
{
disposer.Add(this);
}
public HudController(IHudView hudView, IEventBus eventBus, IDisposer disposer)
{
eventBus.OnEvent <OpenShopCommand>().SubscribeBlind(hudView.Close).AddToDisposer(disposer);
eventBus.OnEvent <CloseShopEvent>().SubscribeBlind(hudView.Open).AddToDisposer(disposer);
}
public static SharedHandle <TRefType> NewHandle <TRefType>(TRefType obj, IDisposer <TRefType> disposer) where TRefType : class
{
return(new SharedHandle <TRefType>(new SharedDisposableObject <TRefType>(obj, disposer)));
}
protected virtual ServiceDescription DeserializeServiceCore(IDisposer disposer, XmlReader reader)
{
try {
var service = CreateService (disposer);
if (service != null) {
service.Deserialize (this, reader);
}
return service;
} catch (Exception e) {
Log.Exception ("There was a problem deserializing a service.", e);
return null;
}
}
