/**
* An intersection of a type predicate and a predicate with a known type is
* equivalent to the known type predicate.
*/
private void RemoveRedundantTypeIntersections(ArrayList newPredicateList, ref bool optimized)
{
int knownTypeId = -1;
for (int i = 0; i < newPredicateList.Count; i++)
{
ResourceListPredicate predicate = (ResourceListPredicate)newPredicateList [i];
if (!(predicate.HasAnyTypePredicate()))
{
int predKnownTypeId = predicate.GetKnownType();
if (knownTypeId == -1)
{
knownTypeId = predKnownTypeId;
}
else if (predKnownTypeId != knownTypeId)
{
return;
}
}
}
if (knownTypeId != -1)
{
for (int i = newPredicateList.Count - 1; i >= 0; i--)
{
if (((ResourceListPredicate)newPredicateList [i]).HasTypePredicate(knownTypeId))
{
newPredicateList.RemoveAt(i);
optimized = true;
}
}
}
}
internal void Instantiate(bool optimize)
{
if (_list == null)
{
ResourceListPredicate oldPredicate = _predicate;
if (optimize)
{
_predicate = _predicate.Optimize(_isLive);
}
if (MyPalStorage.TraceOperations && !(_predicate is PlainListPredicate))
{
if (!Object.ReferenceEquals(oldPredicate, _predicate))
{
Trace.WriteLine("Predicate before optimization: " + oldPredicate.ToString());
}
Trace.WriteLine("Instantiating list " + _predicate.ToString());
}
bool predicateSortedById = false;
_list = _predicate.GetMatchingResources(out predicateSortedById);
if (_isLive && !_handlersAttached)
{
SetLive();
}
if (_lastComparer != null)
{
DoSort(_lastComparer, true);
}
else if (predicateSortedById)
{
_lastComparer = new ResourceComparer(this, new SortSettings(ResourceProps.Id, true), false);
}
}
}
/**
* Optimizes the predicate to make its calculation more efficient.
*/
internal override ResourceListPredicate Optimize(bool isLive)
{
bool optimized = false;
ArrayList newPredicateList = ArrayListPool.Alloc();
try
{
ExpandIntersections(newPredicateList, ref optimized);
RemoveEqualSources(newPredicateList, ref optimized);
RemoveIntersectingUnions(newPredicateList, ref optimized);
RemoveRedundantTypeIntersections(newPredicateList, ref optimized);
ResourceListPredicate result = this;
if (optimized)
{
if (newPredicateList.Count == 1)
{
result = (ResourceListPredicate)newPredicateList [0];
}
else
{
_sourcePredicates = (ResourceListPredicate[])newPredicateList.ToArray(
typeof(ResourceListPredicate));
}
}
return(OptimizeSourcePredicates(result, isLive));
}
finally
{
ArrayListPool.Dispose(newPredicateList);
}
}
internal override IntArrayList GetMatchingResources(out bool sortedById)
{
sortedById = false;
IntArrayList result = null;
for (int i = 0; i < _resTypeIds.Length; i++)
{
ResourceListPredicate basePredicate = new ResourceTypePredicate(_resTypeIds [i]);
ResourceListPredicate cachedPredicate = MyPalStorage.Storage.GetCachedPredicate(basePredicate);
bool tempSortedById = false;
object syncObject = null;
IntArrayList tempResult;
if (cachedPredicate != null)
{
tempResult = cachedPredicate.GetSortedMatchingResourcesRef(out syncObject);
}
else
{
tempResult = basePredicate.GetMatchingResources(out tempSortedById);
syncObject = null;
}
if (result == null)
{
if (syncObject == null)
{
result = tempResult;
}
else
{
lock ( syncObject )
{
result = (IntArrayList)tempResult.Clone();
}
}
}
else
{
if (syncObject == null)
{
result.AddRange(tempResult);
}
else
{
lock ( syncObject )
{
result.AddRange(tempResult);
}
}
}
}
if (result == null)
{
result = new IntArrayList();
}
return(result);
}
protected ResourceListPredicate[] AddPredicate(ResourceListPredicate[] list, ResourceListPredicate pred)
{
int len = list.Length;
ResourceListPredicate[] newList = new ResourceListPredicate [len + 1];
Array.Copy(list, 0, newList, 0, len);
newList [len] = pred;
return(newList);
}
internal virtual ResourceListPredicate Optimize(bool isLive)
{
ResourceListPredicate predicate = MyPalStorage.Storage.GetCachedPredicate(this);
if (predicate != null)
{
return(predicate);
}
return(this);
}
/**
* Checks if one of the predicates in the intersection is equal to the
* specified predicate.
*/
internal bool ContainsPredicate(ResourceListPredicate pred)
{
for (int i = 0; i < _sourcePredicates.Length; i++)
{
if (_sourcePredicates [i].Equals(pred))
{
return(true);
}
}
return(false);
}
internal void AddSource(ResourceListPredicate pred)
{
lock (this)
{
if (_sourcePredicatesSelective != null)
{
if (pred.GetSelectionCost() <= _minSelectionCost)
{
_sourcePredicatesSelective = AddPredicate(_sourcePredicatesSelective, pred);
}
else
{
_sourcePredicatesFiltering = AddPredicate(_sourcePredicatesFiltering, pred);
}
}
_sourcePredicates = AddPredicate(_sourcePredicates, pred);
}
}
protected ResourceListPredicate OptimizeSourcePredicates(ResourceListPredicate result, bool isLive)
{
if (result == this)
{
for (int i = 0; i < _sourcePredicates.Length; i++)
{
_sourcePredicates [i] = _sourcePredicates [i].Optimize(isLive);
}
}
else
{
result = result.Optimize(isLive);
}
ResourceListPredicate predicate = MyPalStorage.Storage.GetCachedPredicate(result);
if (predicate != null)
{
return(predicate);
}
return(result);
}
internal override ResourceListPredicate Optimize(bool isLive)
{
ResourceListPredicate result = this;
if (isLive)
{
int plainListCount = 0;
for (int i = 0; i < _sourcePredicates.Length; i++)
{
PlainListPredicate plainList = _sourcePredicates [i] as PlainListPredicate;
if (plainList != null)
{
plainListCount++;
if (plainListCount > 1 || plainList.Count == 0)
{
result = OptimizePlainLists();
}
}
}
}
return(OptimizeSourcePredicates(result, isLive));
}
internal override ResourceListPredicate Optimize( bool isLive )
{
_lhs = _lhs.Optimize( isLive );
_rhs = _rhs.Optimize( isLive );
return base.Optimize( isLive );
}
internal MinusPredicate( ResourceListPredicate lhs, ResourceListPredicate rhs )
{
_lhs = lhs;
_rhs = rhs;
}
internal void AddSource(ResourceListPredicate pred)
{
_sourcePredicates = AddPredicate(_sourcePredicates, pred);
}
protected internal ResourceList(ResourceListPredicate predicate, bool live)
{
_predicate = predicate;
_isLive = live;
}
