public IEnumerable <int> IntoIter()
{
for (var i = Lower; i < Upper; i++)
{
if (Used.Contains(i))
{
continue;
}
yield return(i);
}
}
private static void dfs(Node node)
{
Used.Add(node);
foreach (LinkNode outLink in node.OutLinks)
{
if (!Used.Contains(outLink.NodeEnd))
{
dfs(outLink.NodeEnd);
}
}
}
/**
* 对象入池
**/
public void ReturnObject <T>(T Instance) where T : IPoolable, new()
{
Type Prototype = typeof(T);
if (ObjectDict.ContainsKey(Prototype))
{
Queue <Object> Objects;
List <Object> Used;
bool Result = ObjectDict.TryGetValue(Prototype, out Objects);
if (Result)
{
ObjectUsedRef.TryGetValue(Prototype, out Used);
int Capacity = 0;
CapacityDict.TryGetValue(Prototype, out Capacity);
if (Used.Contains(Instance))
{
//更新使用引用计数
int UsedCount = 0;
ObjectUsedDict.TryGetValue(Prototype, out UsedCount);
UsedCount--;
ObjectUsedDict[Prototype] = UsedCount;
//从使用队列删除,并且将对象加入未使用队列
Used.Remove(Instance);
if (Objects.Count >= Capacity)
{
//空闲对象到达阀值则将对象直接丢弃等待垃圾回收
((IDisposable)Instance).Dispose();
}
else
{
((IPoolable)Instance).Reset();
Objects.Enqueue(Instance);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="Texts"></param>
/// <returns></returns>
private string Expand(string Text, Dictionary <string, string> Locals = null, HashSet <string> Used = null)
{
if (Used == null)
{
Used = new HashSet <string>();
}
string Output = "";
var Tokens = new CTokenReader(new CTokenizer(Text, TokenizeSpaces: true).Tokenize());
Tokens.MoveNextSpace();
while (Tokens.HasMore)
{
bool Stringify = false;
if (Locals != null && Tokens.Current.Raw == "##")
{
Tokens.MoveNextSpace();
}
if (Tokens.Current.Raw == "#")
{
Tokens.MoveNextSpace();
if (Tokens.Current.Type == CTokenType.Identifier)
{
Stringify = true;
}
else
{
Stringify = false;
Output += "#";
}
}
if (Tokens.Current.Type == CTokenType.Identifier)
{
var CurrentIdentifier = Tokens.Current.Raw;
var UpdatedIdentifier = ReplaceSimpleVariable(CurrentIdentifier);
if (UpdatedIdentifier != CurrentIdentifier)
{
Output += UpdatedIdentifier;
Tokens.MoveNextSpace();
continue;
}
switch (CurrentIdentifier)
{
case "__VA_ARGS__":
CurrentIdentifier = "...";
break;
}
if (Locals != null && Locals.ContainsKey(CurrentIdentifier))
{
CurrentIdentifier = Locals[CurrentIdentifier];
if (Stringify)
{
CurrentIdentifier = CToken.Stringify(CurrentIdentifier);
}
Output += CurrentIdentifier;
Tokens.MoveNextSpace();
}
else if (!Used.Contains(CurrentIdentifier) && Context.Macros.ContainsKey(CurrentIdentifier))
{
var Macro = Context.Macros[CurrentIdentifier];
// Constant
if (Macro is MacroConstant)
{
Output += Expand(Macro.Replacement, null, new HashSet <string>(Used.Concat(new[] { CurrentIdentifier })));
Tokens.MoveNextSpace();
}
// Function
else
{
Tokens.MoveNextNoSpace();
Tokens.ExpectCurrent("(");
var MacroFunction = Context.Macros[CurrentIdentifier] as MacroFunction;
if (MacroFunction == null)
{
throw (new Exception("Trying to call a non-function macro"));
}
//Console.WriteLine(":: {0} :: ", Text);
var Parameters = ParseParameterList(Tokens, JustIdentifiers: false);
for (int n = 0; n < Parameters.Length; n++)
{
//Console.WriteLine(" {0}", Parameters[n]);
Parameters[n] = Expand(Parameters[n], Locals, Used);
//Console.WriteLine(" -> {0}", Parameters[n]);
}
var Map = MapFunctionParameters(MacroFunction.Parameters, Parameters);
//foreach (var Item in Map) Console.WriteLine("{0} -> {1}", Item.Key, Item.Value);
Output += Expand(MacroFunction.Replacement, Map, new HashSet <string>(new[] { CurrentIdentifier }));
}
}
else
{
Output += CurrentIdentifier;
Tokens.MoveNextSpace();
}
}
else
{
Output += Tokens.Current.Raw;
Tokens.MoveNextSpace();
}
}
return(Output);
}
private void Check(int column)
{
from = column;
fromPile = FindTableau[from];
if (fromPile.Count == 0)
{
// No cards.
return;
}
// Configure the working tableau.
WorkingTableau.Variation = Variation;
// Find roots.
Roots.Clear();
int row = fromPile.Count;
Roots.Add(row);
while (row > 0)
{
int count = fromPile.GetRunUpAnySuit(row);
row -= count;
Roots.Add(row);
}
int runs = Roots.Count - 1;
if (runs <= 1)
{
// Not at least two runs.
return;
}
// Check first with no uncovering moves.
best = -1;
CheckOne(Move.Empty);
Used.Clear();
for (int i = 0; i < UncoveringMoves.Count; i++)
{
// Make sure the move doesn't interfere.
Move move = UncoveringMoves[i];
if (move.From == from || move.To == from)
{
continue;
}
// Only need to try an uncovered card once.
if (Used.Contains(move.From))
{
continue;
}
Used.Add(move.From);
// The uncovered card has to match a root to be useful.
Card uncoveredCard = FindTableau[move.From][move.FromRow - 1];
bool matchesRoot = false;
for (int j = 1; j < Roots.Count; j++)
{
if (uncoveredCard.IsTargetFor(fromPile[Roots[j]]))
{
matchesRoot = true;
break;
}
}
if (!matchesRoot)
{
continue;
}
// Try again to find a composite single pile move.
move.ToRow = -1;
CheckOne(move);
}
}
