protected MatchResult Matches(object parent, string fieldName, FieldInfo matchField, List <ReferenceWrapper> objects, out ReferenceWrapper result)
{
FieldInfo actualField;
return(Matches(parent, fieldName, matchField, objects, out result, out actualField));
}
/// <inheritdoc />
public async Task UnsubscribeAsync(ReferenceWrapper referenceWrapper, Type messageType)
{
var brokerService = await _brokerServiceLocator.GetBrokerServiceForMessageAsync(messageType);
await brokerService.UnsubscribeAsync(referenceWrapper, messageType.FullName);
}
public static bool WasPostDisposed(ReferenceWrapper obj)
{
return(sPostDisposed.ContainsKey(obj));
}
public static string GetFriendlyName <TObject>(this ReferenceWrapper <TObject> refer)
where TObject : GitObject =>
(refer.CanonicalName == "(no branch)") ?
"HEAD" :
string.IsNullOrWhiteSpace(refer.FriendlyName) ? refer.CanonicalName : refer.FriendlyName;
public virtual Task UnsubscribeAsync(ReferenceWrapper reference, string messageTypeName)
{
return(Task.CompletedTask);
}
private EvaluationSet <T> BuildEvaluationSet(ReferenceWrapper <T> left, ReferenceWrapper <T> right)
{
var distance = innerEvaluator.EvaluateDistance(left.Item, right.Item);
return(new EvaluationSet <T>(left, right, distance));
}
/// <summary>
/// Unregisters a Service or Actor <paramref name="reference"/> as subscriber for messages of type <paramref name="messageTypeName"/>
/// </summary>
/// <param name="reference"></param>
/// <param name="messageTypeName"></param>
/// <returns></returns>
public async Task UnsubscribeAsync(ReferenceWrapper reference, string messageTypeName)
{
await _store.Remove(messageTypeName, reference);
ServiceEventSourceMessage($"Unregistered subscriber: {reference.Name}");
}
/// <summary>
/// Initializes a new instance of <see cref="AlgorithmTimeLimitManager"/> to manage the
/// creation of <see cref="IsolatorLimitResult"/> instances as it pertains to the
/// algorithm manager's time loop
/// </summary>
/// <param name="additionalTimeBucket">Provides a bucket of additional time that can be requested to be
/// spent to give execution time for things such as training scheduled events</param>
/// <param name="timeLoopMaximum">Specifies the maximum amount of time the algorithm is permitted to
/// spend in a single time loop. This value can be overriden if certain actions are taken by the
/// algorithm, such as invoking the training methods.</param>
public AlgorithmTimeLimitManager(ITokenBucket additionalTimeBucket, TimeSpan timeLoopMaximum)
{
_timeLoopMaximum = timeLoopMaximum;
AdditionalTimeBucket = additionalTimeBucket;
_currentTimeStepTime = new ReferenceWrapper <DateTime>(DateTime.MinValue);
}
public static void Save(IValueSink sink, ReferenceWrapper value)
{
Value <DeviceObjectPropertyReference> .Save(sink, value.Item);
}
public static void Save(IValueSink sink, ReferenceWrapper value)
{
Value<DeviceObjectPropertyReference>.Save(sink, value.Item);
}
public StackFrame(ReferenceWrapper reference, FieldInfo field, string depth)
{
mReference = reference;
mField = field;
mDepth = depth;
}
protected override DereferenceResult Perform(ReactionBroadcaster reference, FieldInfo field, List <ReferenceWrapper> objects)
{
if (Matches(reference, "mOnEnterCallback", field, objects))
{
RemoveDelegate <ReactionBroadcaster.BroadcastCallback>(ref reference.mOnEnterCallback, objects);
return(DereferenceResult.ContinueIfReferenced);
}
if (Matches(reference, "mOnExitCallback", field, objects))
{
RemoveDelegate <ReactionBroadcaster.BroadcastCallback>(ref reference.mOnExitCallback, objects);
return(DereferenceResult.ContinueIfReferenced);
}
ReferenceWrapper result;
if (Matches(reference, "mInRadiusSims", field, objects, out result) != MatchResult.Failure)
{
if (Performing)
{
/*
* try
* {
* reference.Dispose();
* }
* catch
* { }
*/
if (result.Valid)
{
RemoveValues(reference.mInRadiusSims, objects);
}
}
return(DereferenceResult.End);
}
result = new ReferenceWrapper();
if (Matches(reference, "mSimsReacting", field, objects, out result) != MatchResult.Failure)
{
if (Performing)
{
/*
* try
* {
* reference.Dispose();
* }
* catch
* { }
*/
if (result.Valid)
{
RemoveKeys(reference.mSimsReacting, objects);
RemoveValues(reference.mSimsReacting, objects);
}
}
return(DereferenceResult.End);
}
if (Matches(reference, "mBroadcastingObject", field, objects))
{
if (Performing)
{
try
{
// Must be prior to the nulling
reference.Dispose();
}
catch
{ }
Remove(ref reference.mBroadcastingObject);
}
return(DereferenceResult.Continue);
}
return(DereferenceResult.Failure);
}
private Task ProcessQueue(CancellationToken cancellationToken, ReferenceWrapper subscriber, string queueName)
{
return(Task.CompletedTask);
}
/// <summary>
/// Returns a 'dead letter queue' for the provided ActorReference, to store undeliverable messages.
/// </summary>
/// <param name="actorReference"></param>
/// <returns></returns>
private async Task <Queue <MessageWrapper> > GetOrAddActorDeadLetterQueueAsync(ReferenceWrapper actorReference)
{
Queue <MessageWrapper> actorDeadLetters;
var state = await StateManager.GetStateAsync <BrokerActorState>(StateKey);
if (!state.SubscriberDeadLetters.TryGetValue(actorReference, out actorDeadLetters))
{
actorDeadLetters = new Queue <MessageWrapper>();
state.SubscriberDeadLetters[actorReference] = actorDeadLetters;
}
return(actorDeadLetters);
}
protected MatchResult Matches(object parent, string fieldName, FieldInfo matchField, List <ReferenceWrapper> objects, out ReferenceWrapper result, out FieldInfo actualField)
{
result = ReferenceWrapper.Empty;
actualField = parent.GetType().GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
object fieldValue = null;
try
{
if (actualField != null)
{
fieldValue = actualField.GetValue(parent);
}
}
catch (Exception e)
{
Common.Exception(fieldName + Common.NewLine + parent.GetType(), e);
return(MatchResult.Failure);
}
if ((fieldValue == null) && (actualField == matchField))
{
return(MatchResult.Success);
}
if (objects.Count > 0)
{
result = objects[objects.Count - 1];
}
if ((result != null) && (result.Equals(fieldValue)))
{
return(MatchResult.Success);
}
else if (actualField == matchField)
{
return(MatchResult.CorrectField);
}
else
{
return(MatchResult.Failure);
}
}
/// <summary>
/// Sends out queued messages for the provided queue.
/// </summary>
/// <param name="cancellationToken"></param>
/// <param name="subscriber"></param>
/// <param name="queueName"></param>
/// <returns></returns>
protected sealed override async Task ProcessQueues(CancellationToken cancellationToken, ReferenceWrapper subscriber, string queueName)
{
var queue = await TimeoutRetryHelper.Execute((token, state) => StateManager.GetOrAddAsync <IReliableConcurrentQueue <MessageWrapper> >(queueName), cancellationToken : cancellationToken);
long messageCount = queue.Count;
if (messageCount == 0L)
{
return;
}
messageCount = Math.Min(messageCount, MaxDequeuesInOneIteration);
ServiceEventSourceMessage($"Processing {messageCount} items from queue {queue.Name} for subscriber: {subscriber.Name}");
for (long i = 0; i < messageCount; i++)
{
cancellationToken.ThrowIfCancellationRequested();
await TimeoutRetryHelper.ExecuteInTransaction(StateManager, async (tx, token, state) =>
{
var result = await queue.TryDequeueAsync(tx, cancellationToken);
if (result.HasValue)
{
try
{
await subscriber.PublishAsync(result.Value);
await BrokerEventsManager.OnMessageDeliveredAsync(queueName, subscriber, result.Value);
}
catch (Exception ex)
{
await BrokerEventsManager.OnMessageDeliveryFailedAsync(queueName, subscriber, result.Value, ex);
throw;
}
}
}, cancellationToken : cancellationToken);
}
}
public void string_representation_for_wrapped_null_is_some_default_value()
{
var wrapper = new ReferenceWrapper(null);
wrapper.ToString().Should().Be("<null>");
}
/// <summary>
/// Initializes a new instance of the <see cref="ManualTimeProvider"/> class
/// </summary>
/// <param name="currentTime">The current time in the specified time zone, if the time zone is
/// null then the time is interpreted as being in <see cref="TimeZones.Utc"/></param>
/// <param name="setCurrentTimeTimeZone">Specify to use this time zone when calling <see cref="SetCurrentTime"/>,
/// leave null for the default of <see cref="TimeZones.Utc"/></param>
public ManualTimeProvider(DateTime currentTime, DateTimeZone setCurrentTimeTimeZone = null)
: this(setCurrentTimeTimeZone)
{
_currentTime = new ReferenceWrapper <DateTime>(currentTime.ConvertToUtc(_setCurrentTimeTimeZone));
}
/// <summary>
/// Registers a Service or Actor <paramref name="reference"/> as subscriber for messages of type <paramref name="messageTypeName"/>
/// </summary>
/// <param name="reference">Reference to the Service or Actor to register.</param>
/// <param name="messageTypeName">Full type name of message object.</param>
/// <returns></returns>
public async Task SubscribeAsync(ReferenceWrapper reference, string messageTypeName)
{
await _store.AddOrUpdate(messageTypeName, reference);
ServiceEventSourceMessage($"Registered subscriber: {reference.Name}");
}
/// <summary>
/// Sets the current time interpreting the specified time as a UTC time
/// </summary>
/// <param name="time">The current time in UTC</param>
public void SetCurrentTimeUtc(DateTime time)
{
_currentTime = new ReferenceWrapper <DateTime>(time);
}
/// <summary>
/// Sends out queued messages for the provided queue.
/// </summary>
/// <param name="cancellationToken"></param>
/// <param name="subscriber"></param>
/// <param name="queueName"></param>
/// <returns></returns>
protected sealed override async Task ProcessQueues(CancellationToken cancellationToken, ReferenceWrapper subscriber, string queueName)
{
var queue = await TimeoutRetryHelper.Execute((token, state) => StateManager.GetOrAddAsync <IReliableQueue <MessageWrapper> >(queueName), cancellationToken : cancellationToken);
long messageCount = await TimeoutRetryHelper.ExecuteInTransaction(StateManager, (tx, token, state) => queue.GetCountAsync(tx), cancellationToken : cancellationToken);
if (messageCount == 0L)
{
return;
}
messageCount = Math.Min(messageCount, MaxDequeuesInOneIteration);
ServiceEventSourceMessage($"Processing {messageCount} items from queue {queue.Name} for subscriber: {subscriber.Name}");
for (long i = 0; i < messageCount; i++)
{
cancellationToken.ThrowIfCancellationRequested();
await TimeoutRetryHelper.ExecuteInTransaction(StateManager, async (tx, token, state) =>
{
var message = await queue.TryDequeueAsync(tx);
if (message.HasValue)
{
await subscriber.PublishAsync(message.Value);
}
}, cancellationToken : cancellationToken);
}
}
/// <summary>
/// Advances the current time by the specified span
/// </summary>
/// <param name="span">The amount of time to advance the current time by</param>
public void Advance(TimeSpan span)
{
_currentTime = new ReferenceWrapper <DateTime>(_currentTime.Value + span);
}
public Task SubscribeAsync(ReferenceWrapper reference, string messageTypeName, bool isOrdered)
{
return(Task.CompletedTask);
}
/// <summary> /// Sends out queued messages for the provided queue. /// </summary> /// <param name="cancellationToken"></param> /// <param name="subscriber"></param> /// <param name="queueName"></param> /// <returns></returns> protected abstract Task ProcessQueues(CancellationToken cancellationToken, ReferenceWrapper subscriber, string queueName);
public EvaluationSet(ReferenceWrapper <T> item1, ReferenceWrapper <T> item2, decimal distance)
{
Item1 = item1;
Item2 = item2;
Distance = distance;
}
/// <summary>
/// Creates a deadletter queuename to use for this reference. (not message specific)
/// </summary>
/// <returns></returns>
private static string CreateQueueName(ReferenceWrapper reference, string messageTypeName)
{
return($"{messageTypeName}_{reference.GetQueueName()}");
}
/// <summary>
/// Updates the market capacity for any Symbols that require a market update.
/// Sometimes, after the specified <seealso cref="_snapshotPeriod"/>, we
/// take a "snapshot" (point-in-time capacity) of the portfolio's capacity.
///
/// This result will be written into the Algorithm Statistics via the <see cref="BacktestingResultHandler"/>
/// </summary>
public void UpdateMarketCapacity(bool forceProcess)
{
for (var i = _monitoredSymbolCapacity.Count - 1; i >= 0; --i)
{
var capacity = _monitoredSymbolCapacity[i];
if (capacity.UpdateMarketCapacity())
{
_monitoredSymbolCapacity.RemoveAt(i);
_monitoredSymbolCapacitySet.Remove(capacity);
}
}
var utcDate = _algorithm.UtcTime.Date;
if (forceProcess || utcDate >= _nextSnapshotDate && _capacityBySymbol.Count != 0)
{
var totalPortfolioValue = _algorithm.Portfolio.TotalPortfolioValue;
var totalSaleVolume = _capacityBySymbol.Values
.Sum(s => s.SaleVolume);
if (totalPortfolioValue == 0 || _capacityBySymbol.Count == 0)
{
return;
}
var smallestAsset = _capacityBySymbol.Values
.OrderBy(c => c.MarketCapacityDollarVolume)
.First();
_smallestAssetSymbol = smallestAsset.Security.Symbol;
// When there is no trading, rely on the portfolio holdings
var percentageOfSaleVolume = totalSaleVolume != 0
? smallestAsset.SaleVolume / totalSaleVolume
: 0;
var buyingPowerUsed = smallestAsset.Security.MarginModel.GetReservedBuyingPowerForPosition(new ReservedBuyingPowerForPositionParameters(smallestAsset.Security))
.AbsoluteUsedBuyingPower *smallestAsset.Security.Leverage;
var percentageOfHoldings = buyingPowerUsed / totalPortfolioValue;
var scalingFactor = Math.Max(percentageOfSaleVolume, percentageOfHoldings);
var dailyMarketCapacityDollarVolume = smallestAsset.MarketCapacityDollarVolume / smallestAsset.Trades;
var newCapacity = scalingFactor == 0
? Capacity.Value
: dailyMarketCapacityDollarVolume / scalingFactor;
if (Capacity.Value == 0)
{
Capacity = new ReferenceWrapper <decimal>(newCapacity);
}
else
{
Capacity = new ReferenceWrapper <decimal>((0.33m * newCapacity) + (Capacity.Value * 0.66m));
}
foreach (var capacity in _capacityBySymbol.Select(pair => pair.Value).ToList())
{
if (!capacity.ShouldRemove())
{
capacity.Reset();
continue;
}
// we remove non invested and non tradable (delisted, deselected) securities this will allow the 'smallestAsset'
// to be changing between snapshots, and avoid the collections to grow
_capacityBySymbol.Remove(capacity.Security.Symbol);
_monitoredSymbolCapacity.Remove(capacity);
_monitoredSymbolCapacitySet.Remove(capacity);
}
_nextSnapshotDate = utcDate + _snapshotPeriod;
}
}
protected override DereferenceResult Perform(Sim reference, FieldInfo field, List <ReferenceWrapper> objects)
{
if (Matches(reference, "PostureChanged", field, objects))
{
Sim.PostureChangedCallback callback = FindLast <Sim.PostureChangedCallback>(objects);
if (callback != null)
{
reference.PostureChanged -= callback;
}
return(DereferenceResult.End);
}
if (Matches(reference, "mSimDescription", field, objects))
{
if (Performing)
{
//Remove(ref reference.mSimDescription);
return(DereferenceResult.End);
}
else
{
return(DereferenceResult.Found);
}
}
if (Matches(reference, "PetSittingOnGround", field, objects))
{
if (Performing)
{
try
{
reference.PetSittingOnGround.Dispose();
}
catch
{ }
if (reference.HasBeenDestroyed)
{
Remove(ref reference.PetSittingOnGround);
}
else
{
reference.SacsInit();
}
}
return(DereferenceResult.End);
}
if (Matches(reference, "mDeepSnowEffectManager", field, objects))
{
Remove(ref reference.mDeepSnowEffectManager);
return(DereferenceResult.End);
}
if (Matches(reference, "mBridgeOrigin", field, objects))
{
Remove(ref reference.mBridgeOrigin);
return(DereferenceResult.End);
}
if (Matches(reference, "mActiveSwitchOutfitHelper", field, objects))
{
if (Performing)
{
try
{
reference.mActiveSwitchOutfitHelper.Dispose();
}
catch
{ }
Remove(ref reference.mActiveSwitchOutfitHelper);
}
return(DereferenceResult.End);
}
if (Matches(reference, "mClothingReactionBroadcaster", field, objects))
{
if (Performing)
{
try
{
reference.mClothingReactionBroadcaster.Dispose();
}
catch
{ }
Remove(ref reference.mClothingReactionBroadcaster);
}
return(DereferenceResult.End);
}
if (Matches(reference, "PartyAnimalWooList", field, objects))
{
Remove(reference.PartyAnimalWooList, objects);
return(DereferenceResult.End);
}
ReferenceWrapper result;
if (Matches(reference, "SimsReactedToGhost", field, objects, out result) != MatchResult.Failure)
{
if (result.Valid)
{
Remove(reference.SimsReactedToGhost, objects);
}
return(DereferenceResult.End);
}
if (Matches(reference, "PostureChanged", field, objects, out result) != MatchResult.Failure)
{
if (result.Valid)
{
RemoveDelegate <Sim.PostureChangedCallback>(ref reference.PostureChanged, objects);
}
return(DereferenceResult.End);
}
if (Matches(reference, "SynchronizationTarget", field, objects))
{
Remove(ref reference.SynchronizationTarget);
return(DereferenceResult.End);
}
if (Matches(reference, "Bed", field, objects, out result) != MatchResult.Failure)
{
if (result.Valid)
{
Remove(ref reference.Bed);
}
return(DereferenceResult.End);
}
if (Matches(reference, "mSituationSpecificInteractions", field, objects))
{
RemoveKeys(reference.mSituationSpecificInteractions, objects);
RemoveValues(reference.mSituationSpecificInteractions, objects);
return(DereferenceResult.End);
}
if (Matches(reference, "ProgressMeter", field, objects))
{
Remove(ref reference.ProgressMeter);
return(DereferenceResult.End);
}
if (Matches(reference, "PerformanceMeter", field, objects))
{
Remove(ref reference.PerformanceMeter);
return(DereferenceResult.End);
}
result = new ReferenceWrapper();
if (Matches(reference, "ReservedVehicle", field, objects, out result) != MatchResult.Failure)
{
if (result.Valid)
{
Remove(ref reference.ReservedVehicle);
}
return(DereferenceResult.End);
}
result = new ReferenceWrapper();
if (Matches(reference, "ReservedBoat", field, objects, out result) != MatchResult.Failure)
{
if (result.Valid)
{
Remove(ref reference.ReservedBoat);
}
return(DereferenceResult.End);
}
if (Matches(reference, "SynchronizationTarget", field, objects))
{
if (Performing)
{
try
{
reference.ClearSynchronizationData();
}
catch
{ }
Remove(ref reference.SynchronizationTarget);
}
return(DereferenceResult.End);
}
if (Matches(reference, "mBridgeOrigin", field, objects))
{
Remove(ref reference.mBridgeOrigin);
return(DereferenceResult.End);
}
if (Matches(reference, "mPosture", field, objects, out result) != MatchResult.Failure)
{
if (Performing)
{
if (result.Valid)
{
try
{
reference.Posture = null;
}
catch
{ }
}
}
return(DereferenceResult.End);
}
if (Matches(reference, "smcCarry", field, objects))
{
if (Performing)
{
try
{
reference.smcCarry.Dispose();
}
catch
{ }
Remove(ref reference.smcCarry);
}
return(DereferenceResult.End);
}
return(DereferenceResult.Failure);
}
