internal static void AddExpirable(IExpirable e)
{
lock (things)
{
things.Add(e);
}
}
/// <summary>
/// registers an item with a specific eviction condition. If the condition is mutable, every touch/get of the item will result
/// in a condition mutation.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="evictionCondition">may be null</param>
public virtual void Commit(ICommitBag cb, IExpirable evictionCondition)
{
lock (this._stateLock)
{
//commit first. if it kacks we don't do anything
this.Decorated.Commit(cb);
//build and commit the conditions
CommitBag conditionCommitBag = new CommitBag();
//foreach add, register a condition
cb.ItemsToSave.WithEach(x =>
{
//save the eviction condition in the eviction store, keyed by the storedobjectid of the item to save
var conditionToSave = x.GetStoredObjectId().BuildAsId().HasContext(evictionCondition);
conditionCommitBag.MarkItemSaved(conditionToSave);
});
//foreach remove, remove a condition
cb.ItemsToDelete.WithEach(x =>
{
var delId = StoredObjectId.New(typeof(ContextualIHasIdDecoration), x);
conditionCommitBag.MarkItemDeleted(delId);
});
this.ExpirableStore.Commit(conditionCommitBag);
}
}
public void Remove(IExpirable item)
{
lock (_items)
_items.Remove(item);
// reset current timer and repeat
Trigger();
}
internal static void Expire(IExpirable e)
{
lock (things)
{
things.Remove(e);
}
}
public static Polyface IsHasExpirable(this Polyface root, IExpirable expirable)
{
Condition.Requires(root).IsNotNull();
var composited = new HasExpirable(expirable);
root.Is(composited);
return root;
}
/// <summary>
/// 判断指定实体是否已过期
/// </summary>
/// <param name="entity">要检测的实体</param>
/// <returns></returns>
public static bool IsExpired(this IExpirable entity)
{
Check.NotNull(entity, nameof(entity));
DateTime now = DateTime.Now;
return(entity.BeginTime != null && entity.BeginTime.Value > now || entity.EndTime != null && entity.EndTime.Value < now);
}
public static Polyface IsHasExpirable(this Polyface root, IExpirable expirable)
{
Condition.Requires(root).IsNotNull();
var composited = new HasExpirable(expirable);
root.Is(composited);
return(root);
}
public static void SaveEvictingItem(this IEvictingStore store, IHasId obj, IExpirable evictingCondition)
{
if (store == null)
{
return;
}
store.Commit(new CommitBag().MarkItemSaved(obj), evictingCondition);
}
private void Tick(object sender, EventArgs e)
{
for (int i = collection.Count - 1; i >= 0; i--)
{
IExpirable expirable = collection[i];
if ((DateTime.Now - expirable.Time) >= expiration)
{
collection.RemoveAt(i);
}
}
}
void AddExpireDependency(IExpirable dependency)
{
if (dependency.HasExpired)
{
MakeExpired();
}
else
{
dependency.Expired += delegate { MakeExpired(); };
}
}
internal LocalVariable(string name,
Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
:base (name,
process,
expireDependencies,
mutateDependencies,
corValueGetter)
{
}
internal ArrayElement(uint[] indicies,
Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
:base (GetNameFromIndices(indicies),
process,
expireDependencies,
mutateDependencies,
corValueGetter)
{
this.indicies = indicies;
}
internal MemberValue(MemberInfo memberInfo,
Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
:base (memberInfo.Name,
process,
expireDependencies,
mutateDependencies,
corValueGetter)
{
this.memberInfo = memberInfo;
}
/// <summary>
/// the eviction event raiser
/// </summary>
/// <param name="ci"></param>
public void OnItemEvicted(IHasId iHasId, IExpirable condition)
{
//skip if no listeners attached
if (this.ItemEvicted == null)
{
return;
}
var args = this.ItemEvicted.BuildEventArgs(new Tuple <IHasId, IExpirable>(iHasId, condition));
//fire the event
this.ItemEvicted(this, args);
}
internal MethodArgument(string name,
int index,
Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
:base (name,
process,
expireDependencies,
mutateDependencies,
corValueGetter)
{
this.index = index;
}
/// <summary>
/// examines all eviction conditions and removes items that have an eviction condition of true.
/// If an item's eviction condition is mutable, it will be mutated (eg. touched) on every get
/// </summary>
public void Evict()
{
List <ContextualIHasIdDecoration> itemsToEvict = new List <ContextualIHasIdDecoration>();
//search the eviction store for evicts
var evictions = this.ExpirableStore.GetAll();
foreach (var each in evictions)
{
var eachItem = each as ContextualIHasIdDecoration;
if (eachItem != null && eachItem.Context != null)
{
IExpirable exp = eachItem.Context as IExpirable;
if (exp.IsExpired())
{
itemsToEvict.Add(eachItem);
}
}
}
//build deletes and commit them
var mainCommitBag = new CommitBag();
var expCommitBag = new CommitBag();
itemsToEvict.WithEach(x =>
{
StoredObjectId soid = x.Id as StoredObjectId;
mainCommitBag.MarkItemDeleted(soid);
expCommitBag.MarkItemDeleted(x.GetStoredObjectId());
});
//remove the item specified by the expirable policy.
this.Commit(mainCommitBag);
//now delete from the expiry store
this.ExpirableStore.Commit(expCommitBag);
//raise events (outside of state lock)
itemsToEvict.WithEach(x =>
{
this.OnItemEvicted(x, x.Context as IExpirable);
});
}
internal NamedValue(string name,
Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
:base (process,
expireDependencies,
mutateDependencies,
corValueGetter)
{
this.name = name;
// TODO: clean up
if (name.StartsWith("<") && name.Contains(">") && name != "<Base class>") {
string middle = name.TrimStart('<').Split('>')[0]; // Get text between '<' and '>'
if (middle != "") {
this.name = middle;
}
}
}
public override IDecorationOf<IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
Condition.Requires(thing).IsOfType(typeof(DateExpirableDecoration));
return new FloatingDateExpirableDecoration((DateExpirableDecoration)thing, this.TouchIncrementSecs);
}
public override IDecorationOf <IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
Condition.Requires(thing).IsOfType(typeof(DateExpirableDecoration));
return(new FloatingDateExpirableDecoration((DateExpirableDecoration)thing, this.TouchIncrementSecs));
}
public WindowExpirableDecoration(IExpirable decorated, DateTime startDate, DateTime endDate)
: base(decorated)
{
this.StartDate = startDate.ToUniversalTime();
this.EndDate = endDate.ToUniversalTime();
}
public ExpiringLogicDecoration(ILogic decorated, IExpirable expirable)
: base(decorated)
{
Condition.Requires(expirable).IsNotNull();
this.Expirable = expirable;
}
public static HasExpirable New(IExpirable exp)
{
return new HasExpirable(exp);
}
public static ExpiringValueOfDecoration <T> HasExpirable <T>(this IValueOf <T> decorated, IExpirable expirable)
{
Condition.Requires(decorated).IsNotNull();
return(new ExpiringValueOfDecoration <T>(decorated, expirable));
}
public DateExpirableDecoration(IExpirable decorated, DateTime expiryDate)
: base(decorated)
{
this.ExpiryDate = expiryDate.ToUniversalTime();
}
public static WindowExpirableDecoration DecorateWithWindowExpirable(this IExpirable thing, DateTime startDate, DateTime endDate)
{
Condition.Requires(thing).IsNotNull();
return(new WindowExpirableDecoration(thing, startDate, endDate));
}
public override IDecorationOf <IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
return(new WindowExpirableDecoration(thing, this.StartDate, this.EndDate));
}
public WindowExpirableDecoration(IExpirable decorated, DateTime startDate, DateTime endDate)
: base(decorated)
{
this.StartDate = startDate.ToUniversalTime();
this.EndDate = endDate.ToUniversalTime();
}
/// <summary>
/// 判断指定实体是否已过期
/// </summary>
/// <param name="entity">要检测的实体</param>
/// <returns></returns>
public static bool IsExpired(this IExpirable entity)
{
DateTime now = DateTime.Now;
return(entity.BeginTime != null && entity.BeginTime.Value > now || entity.EndTime != null && entity.EndTime.Value < now);
}
void AddExpireDependency(IExpirable dependency)
{
if (dependency.HasExpired) {
MakeExpired();
} else {
dependency.Expired += delegate { MakeExpired(); };
}
}
internal Value(Process process,
IExpirable[] expireDependencies,
IMutable[] mutateDependencies,
CorValueGetter corValueGetter)
{
this.process = process;
AddExpireDependency(process);
foreach(IExpirable exp in expireDependencies) {
AddExpireDependency(exp);
}
foreach(IMutable mut in mutateDependencies) {
AddMutateDependency(mut);
}
this.corValueGetter = corValueGetter;
}
public static ConditionalExpirableDecoration DecorateWithConditionalExpirable(this IExpirable thing, ICondition condition)
{
Condition.Requires(thing).IsNotNull();
return(new ConditionalExpirableDecoration(thing, condition));
}
public void Commit(ICommitBag cb, IExpirable expirable)
{
this.As<EvictingDecoration>(true).Commit(cb, expirable);
}
public HasExpirable(IExpirable expirable)
{
Condition.Requires(expirable).IsNotNull();
this.Expirable = expirable;
}
public ExpiringValueOfDecoration(IValueOf <T> decorated, IExpirable expirable)
: base(decorated)
{
Condition.Requires(expirable).IsNotNull();
this.Expirable = expirable;
}
/// <summary>
/// the eviction event raiser
/// </summary>
/// <param name="ci"></param>
public void OnItemEvicted(IHasId iHasId, IExpirable condition)
{
//skip if no listeners attached
if (this.ItemEvicted == null)
return;
var args = this.ItemEvicted.BuildEventArgs(new Tuple<IHasId, IExpirable>(iHasId, condition));
//fire the event
this.ItemEvicted(this, args);
}
public HasExpirable(IExpirable expirable)
{
Condition.Requires(expirable).IsNotNull();
this.Expirable = expirable;
}
public static bool IsExpired(this IExpirable token)
{
return(token.ExpireAt <= DateTime.UtcNow);
}
private void RefineExpirable(IExpirable expirable)
{
expirable.ValidFrom = Now;
}
public override IDecorationOf <IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
return(new ConditionalExpirableDecoration(thing, this.ExpiryCondition));
}
public static ExpiringLogicDecoration HasExpirable(this ILogic decorated, IExpirable expirable)
{
Condition.Requires(decorated).IsNotNull();
return(new ExpiringLogicDecoration(decorated, expirable));
}
public static ExpiringLogicDecoration HasExpirable(this ILogic decorated, IExpirable expirable)
{
Condition.Requires(decorated).IsNotNull();
return new ExpiringLogicDecoration(decorated, expirable);
}
public override IDecorationOf<IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
return new WindowExpirableDecoration(thing, this.StartDate, this.EndDate);
}
public override IDecorationOf<IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
return new ConditionalExpirableDecoration(thing, this.ExpiryCondition);
}
public static void SaveEvictingItem(this IEvictingStore store, IHasId obj, IExpirable evictingCondition)
{
if (store == null)
return;
store.Commit(new CommitBag().MarkItemSaved(obj), evictingCondition);
}
public override IDecorationOf<IExpirable> ApplyThisDecorationTo(IExpirable thing)
{
return new DateExpirableDecoration(thing, this.ExpiryDate);
}
public ExpiringLogicDecoration(ILogic decorated, IExpirable expirable)
: base(decorated)
{
Condition.Requires(expirable).IsNotNull();
this.Expirable = expirable;
}
public static HasExpirable New(IExpirable exp)
{
return(new HasExpirable(exp));
}
public ConditionalExpirableDecoration(IExpirable decorated, ICondition expiryCondition)
: base(decorated)
{
this.ExpiryCondition = expiryCondition;
}
public ConditionalExpirableDecoration(IExpirable decorated, ICondition expiryCondition)
: base(decorated)
{
this.ExpiryCondition = expiryCondition;
}
public void Commit(ICommitBag cb, IExpirable expirable)
{
this.As <EvictingDecoration>(true).Commit(cb, expirable);
}
/// <summary>
/// registers an item with a specific eviction condition. If the condition is mutable, every touch/get of the item will result
/// in a condition mutation.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="evictionCondition">may be null</param>
public virtual void Commit(ICommitBag cb, IExpirable evictionCondition)
{
lock (this._stateLock)
{
//commit first. if it kacks we don't do anything
this.Decorated.Commit(cb);
//build and commit the conditions
CommitBag conditionCommitBag = new CommitBag();
//foreach add, register a condition
cb.ItemsToSave.WithEach(x =>
{
//save the eviction condition in the eviction store, keyed by the storedobjectid of the item to save
var conditionToSave = x.GetStoredObjectId().BuildAsId().HasContext(evictionCondition);
conditionCommitBag.MarkItemSaved(conditionToSave);
});
//foreach remove, remove a condition
cb.ItemsToDelete.WithEach(x =>
{
var delId = StoredObjectId.New(typeof(ContextualIHasIdDecoration), x);
conditionCommitBag.MarkItemDeleted(delId);
});
this.ExpirableStore.Commit(conditionCommitBag);
}
}
