public static System.Reflection.Assembly GenerateCode(ITextTemplatingEngineHost host, ParsedTemplate pt,
TemplateSettings settings, CodeCompileUnit ccu)
{
CompilerParameters pars = new CompilerParameters ();
pars.GenerateExecutable = false;
if (settings.Debug) {
pars.GenerateInMemory = false;
pars.IncludeDebugInformation = true;
pars.TempFiles.KeepFiles = true;
} else {
pars.GenerateInMemory = true;
pars.IncludeDebugInformation = false;
}
//resolve and add assembly references
HashSet<string> assemblies = new HashSet<string> ();
assemblies.UnionWith (settings.Assemblies);
assemblies.UnionWith (host.StandardAssemblyReferences);
foreach (string assem in assemblies) {
string resolvedAssem = host.ResolveAssemblyReference (assem);
if (!String.IsNullOrEmpty (resolvedAssem)) {
pars.ReferencedAssemblies.Add (resolvedAssem);
} else {
pt.LogError ("Could not resolve assembly reference '" + assem + "'");
return null;
}
}
CompilerResults results = settings.Provider.CompileAssemblyFromDom (pars, ccu);
pt.Errors.AddRange (results.Errors);
if (pt.Errors.HasErrors)
return null;
return results.CompiledAssembly;
}
static void Main()
{
InitializeWordsByChar();
int textLinesCount = int.Parse(Console.ReadLine().ToLower());
for (int i = 0; i < textLinesCount; i++)
{
GetWords(Console.ReadLine().ToLower());
}
int wordsCount = int.Parse(Console.ReadLine());
for (int i = 0; i < wordsCount; i++)
{
string word = Console.ReadLine();
string wordLowerCase = word.ToLower();
HashSet<string> currentWords = new HashSet<string>();
currentWords.UnionWith(wordsByChar[wordLowerCase[0]]);
for (int j = 1; j < wordLowerCase.Length; j++)
{
currentWords.IntersectWith(wordsByChar[wordLowerCase[j]]);
}
Console.WriteLine("{0} -> {1}", word, currentWords.Count);
}
}
/// <summary>
/// Gather member which provide continuity with the specified member
/// </summary>
/// <param name="Member"></param>
/// <returns></returns>
public static IEnumerable<Member> GatherParallelMembers(Member Member, Node LastNode = null, bool MoveDownstream = false)
{
Node currentNode;
Member nextMember;
IEnumerable<Member> connectedParallelMembers;
HashSet<Member> parallelMembers;
parallelMembers = new HashSet<Member>();
if (MoveDownstream)
parallelMembers.Add(Member);
// Determine which will be the next node
currentNode = MemberHelpers.DetermineNextNode(Member, LastNode, MoveDownstream);
connectedParallelMembers = currentNode.ConnectedBeams.Select(b => b.Member).Where(m => m != null && m != Member && m.DetermineMemberRelation(Member) == MEMBERRELATION.PARALLEL);
if (connectedParallelMembers.Any())
{
nextMember = connectedParallelMembers.First();
parallelMembers.UnionWith(GatherParallelMembers(nextMember, currentNode, MoveDownstream));
}
else
{
if (!MoveDownstream)
parallelMembers.UnionWith(GatherParallelMembers(Member, currentNode, true));
}
return parallelMembers;
}
private HashSet<string> GetUserAssemblies(string managedDir)
{
HashSet<string> stringSet = new HashSet<string>();
stringSet.UnionWith(this.FilterUserAssemblies((IEnumerable<string>) this.m_RuntimeClassRegistry.GetUserAssemblies(), new Predicate<string>(this.m_RuntimeClassRegistry.IsDLLUsed), managedDir));
stringSet.UnionWith(this.FilterUserAssemblies((IEnumerable<string>) Directory.GetFiles(managedDir, "I18N*.dll", SearchOption.TopDirectoryOnly), (Predicate<string>) (assembly => true), managedDir));
return stringSet;
}
/// <summary>
/// Gather beams which provide continuity with the specified beam
/// </summary>
/// <param name="Beam">The start beam around which to contruct the chain</param>
/// <returns></returns>
public static IEnumerable<Beam> GatherParallelBeams(Beam Beam, Node LastNode = null, bool MoveDownstream = false)
{
Node currentNode;
Beam nextBeam;
IEnumerable<Beam> connectedParallelBeams;
HashSet<Beam> parallelBeams;
parallelBeams = new HashSet<Beam>();
if (MoveDownstream)
parallelBeams.Add(Beam);
// Determine which will be the next node depending on the beam orientation and direction of travel
currentNode = BeamHelpers.DetermineNextNode(Beam, LastNode, MoveDownstream);
// Check if the are any parallel beams among the connected beams and start gathering the beams depending on the direction of travel
connectedParallelBeams = currentNode.ConnectedBeams.Where(b => b != null && b != Beam && b.DetermineBeamRelationship(Beam) == BEAMRELATION.PARALLEL);
if (connectedParallelBeams.Any())
{
nextBeam = connectedParallelBeams.First();
parallelBeams.UnionWith(GatherParallelBeams(nextBeam, currentNode, MoveDownstream));
}
else
{
if (!MoveDownstream)
parallelBeams.UnionWith(GatherParallelBeams(Beam, currentNode, true));
}
return parallelBeams;
}
public ISet<int> GetNodes()
{
var retVal = new HashSet<int>();
retVal.UnionWith(playerZeroNodes);
retVal.UnionWith(playerOneNodes);
return retVal;
}
public ICollection<Type> GetControllerTypes(string controllerName, HashSet<string> namespaces) {
HashSet<Type> matchingTypes = new HashSet<Type>();
ILookup<string, Type> nsLookup;
if (_cache.TryGetValue(controllerName, out nsLookup)) {
// this friendly name was located in the cache, now cycle through namespaces
if (namespaces != null) {
foreach (string requestedNamespace in namespaces) {
foreach (var targetNamespaceGrouping in nsLookup) {
if (IsNamespaceMatch(requestedNamespace, targetNamespaceGrouping.Key)) {
matchingTypes.UnionWith(targetNamespaceGrouping);
}
}
}
}
else {
// if the namespaces parameter is null, search *every* namespace
foreach (var nsGroup in nsLookup) {
matchingTypes.UnionWith(nsGroup);
}
}
}
return matchingTypes;
}
static AssignmentStatementParser()
{
COLON_EQUALS_SET = new HashSet<TokenType>();
COLON_EQUALS_SET.Add(TokenType.COLON_EQUALS);
COLON_EQUALS_SET.UnionWith(ExpressionParser.EXPR_START_SET);
COLON_EQUALS_SET.UnionWith(StatementParser.STMT_FOLLOW_SET);
}
public static HashSet<string> iu_cs_sinalling_relation_delegate_imsi(List<streamMessagePool._stream_message> ml, string imsi, bool sFlag)
{
//哈希表收集关联因子
HashSet<string> hs = new HashSet<string>();
hs.Add(imsi);
//lr关联收集sccp连接串slr
IEnumerable<string> l_slr_opc =
from n in ml
where n.message_gsm_a_imsi == imsi & n.message_sccp_slr != null
select n.message_sccp_slr + n.message_source
into m
where m.Contains("0x")
select m;
hs.UnionWith(l_slr_opc);
if (l_slr_opc.Any())
foreach (string slr_opc in l_slr_opc)
hs.UnionWith(iu_cs_sinalling_relation_delegate_lr(ml, slr_opc, sFlag));
//lr关联收集sccp连接串dlr
IEnumerable<string> l_dlr_dpc =
from n in ml
where n.message_gsm_a_imsi == imsi & n.message_sccp_dlr != null
select n.message_sccp_dlr + n.message_destination
into m
where m.Contains("0x")
select m;
hs.UnionWith(l_dlr_dpc);
if (l_dlr_dpc.Any())
foreach (string dlr_dpc in l_dlr_dpc)
hs.UnionWith(iu_cs_sinalling_relation_delegate_lr(ml, dlr_dpc, sFlag));
return hs;
}
public HashSet<Node> getAllEdges()
{
HashSet<Node> allEdges = new HashSet<Node>();
allEdges.UnionWith(_taxiEdges);
allEdges.UnionWith(_busEdges);
allEdges.UnionWith(_ugEdges);
return allEdges;
}
public HashSet<KeyCode> getKeysHandled()
{
HashSet<KeyCode> keyCodes = new HashSet<KeyCode>();
keyCodes.UnionWith(getKeyDownHandlers().Keys);
keyCodes.UnionWith(getKeyUpHandlers().Keys);
keyCodes.UnionWith(getKeyHandlers().Keys);
return keyCodes;
}
/// <summary>List of cell ids for cells in the same context as the provided cell.</summary>
/// <remarks>The "context" is the union of the Row, Column, and Shape for the provided cell.</remarks>
/// <param name="cell">The cell id to find others in the same context.</param>
/// <returns>The cell ids of all other cells in the same context.</returns>
public virtual IEnumerable<int> Context(int cell)
{
HashSet<Cell> cells = new HashSet<Cell>();
cells.UnionWith(GetRowRegionForCell(cell).Cells);
cells.UnionWith(GetColumnRegionForCell(cell).Cells);
cells.UnionWith(GetShapeRegionForCell(cell).Cells);
return EnumerateIds(cells, cell);
}
public async Task<CodeGenResult> CodeGen(Workspace workspace, Project project)
{
CompilationUnitSyntax cu = SF.CompilationUnit();
var usings = new HashSet<string>();
bool copyUsings = false;
foreach (Document document in project.Documents)
{
SyntaxTree syntaxTree = await document.GetSyntaxTreeAsync();
_semanticModel = await document.GetSemanticModelAsync();
IEnumerable<ClassDeclarationSyntax> classes =
syntaxTree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>();
foreach (var classNode in classes)
{
if (!RoslynUtils.IsPublic(classNode)) continue;
ITypeSymbol swmrInterface = FindSwmrInterface(classNode);
if (swmrInterface == null)
{
continue;
}
var namespaceNode = classNode.Parent as NamespaceDeclarationSyntax;
if (namespaceNode == null)
{
throw new Exception("A grain must be declared inside a namespace");
}
usings.UnionWith(syntaxTree.GetRoot().DescendantNodes().OfType<UsingDirectiveSyntax>().Select(usingDirective => usingDirective.Name.ToString()));
int replicaCount = GetReadReplicaCount(swmrInterface);
NamespaceDeclarationSyntax namespaceDclr = SF.NamespaceDeclaration(SF.IdentifierName(namespaceNode.Name.ToString())).WithUsings(namespaceNode.Usings);
namespaceDclr = namespaceDclr.AddMembers(
GenerateWriteGrain(classNode, swmrInterface, replicaCount),
GenerateReadGrain(classNode, swmrInterface, replicaCount),
GenerateReadReplicaGrain(classNode, swmrInterface)
);
usings.UnionWith(namespaceNode.Usings.Select(@using => @using.Name.ToString()));
cu = cu.AddMembers(namespaceDclr);
// only copy the usings if at least one class was generated
copyUsings = true;
}
}
if (copyUsings)
{
usings.UnionWith(GetCommonUsings());
}
return new CodeGenResult(Formatter.Format(cu, workspace).ToString(), usings);
}
public HashSet<char> GetVariables()
{
HashSet<char> variables = new HashSet<char>();
variables.UnionWith(baseOfLogarithm.GetVariables());
variables.UnionWith(number.GetVariables());
return variables;
}
public IEnumerable<PhonebookEntry> Find(string name)
{
HashSet<PhonebookEntry> matched = new HashSet<PhonebookEntry>();
matched.UnionWith(this.byFirstName[name]);
matched.UnionWith(this.byMiddleName[name]);
matched.UnionWith(this.byLastName[name]);
matched.UnionWith(this.byNickname[name]);
return matched;
}
public HashSet<string> MergeAll()
{
var results = new HashSet<string>();
results.UnionWith(OnlyInSource);
results.UnionWith(OnlyInTarget);
results.UnionWith(DifferentContents);
results.UnionWith(IdenticalContents);
return results;
}
public HashSet<EntityId> GetIds()
{
var set = new HashSet<EntityId>();
set.UnionWith(_phoneDictionary.Select(x=>x.Key));
set.UnionWith(_businessDictionary.Select(x=>x.Key));
set.UnionWith(_personDictionary.Select(x=>x.Key));
set.UnionWith(_locationDictionary.Select(x=>x.Key));
return set;
}
public HashSet<char> GetVariables()
{
HashSet<char> variables = new HashSet<char>();
variables.UnionWith(baseOfPower.GetVariables());
variables.UnionWith(exponent.GetVariables());
return variables;
}
/// <summary>
/// Returns a HashSet of the two pockets and all of their contents.
/// </summary>
/// <returns>
/// a HashSet of the two pockets and all of their contents.
/// </returns>
public HashSet<Thing> GetRecursiveContents()
{
HashSet<Thing> temp = new HashSet<Thing>();
temp.Add(leftPocket);
temp.Add(rightPocket);
temp.UnionWith( leftPocket.GetRecursiveContents());
temp.UnionWith(rightPocket.GetRecursiveContents());
return temp;
}
public HashSet<char> GetVariables()
{
HashSet<char> variables = new HashSet<char>();
variables.UnionWith(nthRoot.GetVariables());
variables.UnionWith(baseOfRoot.GetVariables());
return variables;
}
public IEnumerable<IWatcher> Materialize(KeeperState state, EventType type, string clientPath)
{
HashSet<IWatcher> result = new HashSet<IWatcher>();
switch (type) {
case EventType.None:
result.Add(defaultWatcher);
foreach (var ws in dataWatches.Values) {
result.UnionWith(ws);
}
foreach (var ws in existWatches.Values) {
result.UnionWith(ws);
}
foreach(var ws in childWatches.Values) {
result.UnionWith(ws);
}
// clear the watches if auto watch reset is not enabled
if (ClientConnection.DisableAutoWatchReset &&
state != KeeperState.SyncConnected)
{
dataWatches.Clear();
existWatches.Clear();
childWatches.Clear();
}
return result;
case EventType.NodeDataChanged:
case EventType.NodeCreated:
AddTo(dataWatches.GetAndRemove(clientPath), result);
AddTo(existWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeChildrenChanged:
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeDeleted:
AddTo(dataWatches.GetAndRemove(clientPath), result);
// XXX This shouldn't be needed, but just in case
HashSet<IWatcher> list = existWatches.GetAndRemove(clientPath);
if (list != null) {
AddTo(existWatches.GetAndRemove(clientPath), result);
#if !NET_CORE
LOG.Warn("We are triggering an exists watch for delete! Shouldn't happen!");
#endif
}
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
default:
var msg = new StringBuilder("Unhandled watch event type ").Append(type).Append(" with state ").Append(state).Append(" on path ").Append(clientPath).ToString();
#if !NET_CORE
LOG.Error(msg);
#endif
throw new InvalidOperationException(msg);
}
return result;
}
public IEnumerable<IContact> GetSameContactsAs(IContact c)
{
var hash = new HashSet<IContact>();
hash.UnionWith(GetContactsFor(c.FullName));
foreach (string email in c.Emails)
{
hash.UnionWith(GetContactsFor(email));
}
return hash;
}
private static IEnumerable<Type> MergeKnownTypesWithDynamicProxyTypes(IEnumerable<Type> knownTypes)
{
var tmp = new HashSet<Type>();
if (knownTypes != null)
tmp.UnionWith(knownTypes);
tmp.UnionWith(EfDynamicProxyAssemblies.GetTypes());
return tmp;
}
public IEnumerable<PhonebookEntry> Find(string name, string town)
{
HashSet<PhonebookEntry> matchedByName = new HashSet<PhonebookEntry>();
matchedByName.UnionWith(this.byFirstName[name]);
matchedByName.UnionWith(this.byMiddleName[name]);
matchedByName.UnionWith(this.byLastName[name]);
matchedByName.UnionWith(this.byNickname[name]);
IEnumerable<PhonebookEntry> matchedByNameAndTown =
matchedByName.Where(entry => entry.Town == town);
return matchedByNameAndTown;
}
/// <summary>
/// Find all the possible implementations of the given type.
/// </summary>
public IEnumerable<Type> GetAllConcreteTypes(Type serviceType)
{
var types = new HashSet<Type>();
if (mappings.ContainsKey(serviceType))
types.UnionWith(mappings[serviceType]);
if(Parent != null)
types.UnionWith(Parent.GetAllConcreteTypes(serviceType));
return types;
}
public CryptArithmeticProblem(CryptArithmeticInstanceDescription instanceDescriptor)
{
this.terms = instanceDescriptor.Terms;
this.result = instanceDescriptor.Result;
HashSet<char> charsInExpression = new HashSet<char>();
foreach (string term in terms) {
charsInExpression.UnionWith(term.ToCharArray());
}
charsInExpression.UnionWith(result.ToCharArray());
charArray = charsInExpression.ToArray();
}
public static HashSet<CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.ComponentAssemblies cyPhyMLComponentAssemblies) {
HashSet<CyPhyML.Component> cyPhyMLComponentSet = new HashSet<CyPhyML.Component>();
foreach (CyPhyML.ComponentAssemblies childComponentAssembliesFolder in cyPhyMLComponentAssemblies.Children.ComponentAssembliesCollection) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentAssembliesFolder));
}
foreach (CyPhyML.ComponentAssembly childComponentAssemblyFolder in cyPhyMLComponentAssemblies.Children.ComponentAssemblyCollection) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentAssemblyFolder));
}
return cyPhyMLComponentSet;
}
public void SaveToFile(string suppressionsFilePath)
{
HashSet<string> lines = new HashSet<string>();
lines.Add("[cppcheck]");
lines.UnionWith(SuppressionLines);
lines.Add("[cppcheck_files]");
lines.UnionWith(SkippedFilesMask);
lines.Add("[cppcheck_includes]");
lines.UnionWith(SkippedIncludesMask);
System.IO.FileInfo file = new System.IO.FileInfo(suppressionsFilePath);
file.Directory.Create(); // If the directory already exists, this method does nothing.
File.WriteAllLines(suppressionsFilePath, lines);
}
public static List<List<String>> OrderByCount(List<List<String>> list)
{
list = list.OrderBy(item => item.Count()).ToList();
HashSet<string> sumAll = new HashSet<string>();
HashSet<string> listIntersect = new HashSet<string>();
HashSet<string> listExcept = new HashSet<string>();
HashSet<string> listEndExc = new HashSet<string>();
List<List<string>> tmpIntExc = new List<List<string>>(); // List of lists
int i = 0;
while (i < list.Count() - 1)
{
listIntersect = new HashSet<string>(list[i].Intersect(list[i + 1]));
listIntersect.ExceptWith(sumAll);
sumAll.UnionWith(listIntersect);
listExcept = new HashSet<string>(list[i].Except(list[i + 1]));
listExcept.ExceptWith(sumAll);
sumAll.UnionWith(listExcept);
i++;
if (i == list.Count() - 1)
{
listEndExc = new HashSet<string>(list[list.Count() - 1]);
listEndExc.ExceptWith(sumAll);
}
List<string> kkk = new List<string>(listIntersect);// List of Intersect
List<string> mmm = new List<string>(listExcept);// List of Except
List<string> nnn = new List<string>(listEndExc);
if (kkk.Any())
{
tmpIntExc.Add(kkk);
}
if (mmm.Any())
{
tmpIntExc.Add(mmm);
}
if (nnn.Any())
{
tmpIntExc.Add(nnn);
}
}
return tmpIntExc.OrderBy(l=>l.Count).ThenBy((l=>l.First())).ToList(); //DisplaySet(tmpIntExc);
}
/// <summary>
/// 返回文档所有节点，包括已分配和游离的
/// </summary>
/// <param name="document">查找节点的文档</param>
/// <returns>文档的所有节点</returns>
public static IEnumerable<IHtmlNode> AllNodes( this IHtmlDocument document )
{
if ( document == null )
throw new ArgumentNullException( "document" );
var nodes = new HashSet<IHtmlNode>();
nodes.UnionWith( document.DescendantNodes() );
var manager = document.FragmentManager;
if ( manager != null )
nodes.UnionWith( manager.AllFragments.SelectMany( fragment => fragment.DescendantNodes() ) );
return nodes;
}
public static HashSet <string> RunHoudini(Program program, bool RobustAgainstEvaluate = false)
{
HoudiniStats.Reset();
HoudiniInlining.RobustAgainstEvaluate = DualHoudini? false : RobustAgainstEvaluate;
if (DualHoudini && CommandLineOptions.Clo.InlineDepth > 0)
{
throw new DualHoudiniFail("InlineDepth not supported");
}
// Gather existential constants
var CandidateConstants = new Dictionary <string, Constant>();
program.TopLevelDeclarations.OfType <Constant>()
.Where(c => QKeyValue.FindBoolAttribute(c.Attributes, "existential"))
.Iter(c => CandidateConstants.Add(c.Name, c));
// Create a function, one for each impl, for book-keeping
var CandidateFuncsAssumed = new Dictionary <string, Function>();
var CandidateFuncsAsserted = new Dictionary <string, Function>();
var AssumeToAssert = new Dictionary <Function, Function>();
program.TopLevelDeclarations.OfType <Implementation>()
.Iter(impl =>
{
var fassumed = GetCandidateFunc(CandidateFuncPrefix, impl.Name);
var fasserted = GetCandidateFunc(CandidateFuncAssertedPrefix, impl.Name);
CandidateFuncsAssumed.Add(impl.Name, fassumed);
CandidateFuncsAsserted.Add(impl.Name, fasserted);
AssumeToAssert.Add(fassumed, fasserted);
});
// Tag the ensures so we can keep track of them
var iterimpls = program.TopLevelDeclarations.OfType <Implementation>().ToList();
iterimpls.Iter(impl => InstrumentEnsures(program, impl, CandidateFuncsAssumed[impl.Name], CandidateConstants));
//BoogieUtil.PrintProgram(program, "h2.bpl");
var RewriteAssumedToAssertedAction = new Action <Implementation>(impl =>
{
// Rewrite functions that are asserted
var rewrite = new RewriteFuncs(AssumeToAssert);
foreach (var blk in impl.Blocks)
{
foreach (var acmd in blk.Cmds.OfType <AssertCmd>())
{
acmd.Expr = rewrite.VisitExpr(acmd.Expr);
}
}
var funcs = new HashSet <Function>(CandidateFuncsAssumed.Values);
// Move call-site constant to the first argument of CandidateFuncs
foreach (var blk in impl.Blocks)
{
Expr cv = null;
// walk backwards
for (int i = blk.Cmds.Count - 1; i >= 0; i--)
{
var acmd = blk.Cmds[i] as AssumeCmd;
if (acmd == null)
{
continue;
}
if (QKeyValue.FindBoolAttribute(acmd.Attributes, StratifiedVCGenBase.callSiteVarAttr))
{
cv = acmd.Expr;
continue;
}
InsertControlVar.Apply(acmd.Expr, funcs, cv);
}
}
//impl.Emit(new TokenTextWriter(Console.Out), 0);
});
program.AddTopLevelDeclarations(CandidateFuncsAssumed.Values);
program.AddTopLevelDeclarations(CandidateFuncsAsserted.Values);
var callgraph = BoogieUtil.GetCallGraph(program);
var impl2Priority = DeterminePriorityOrder(program, callgraph);
var impls = new HashSet <string>(impl2Priority.Keys);
HoudiniStats.Start("VCGen");
// VC Gen
var hi = new HoudiniInlining(program, CommandLineOptions.Clo.SimplifyLogFilePath, CommandLineOptions.Clo.SimplifyLogFileAppend, RewriteAssumedToAssertedAction);
HoudiniStats.Stop("VCGen");
var worklist = new SortedSet <Tuple <int, string> >();
impl2Priority.Iter(tup => worklist.Add(Tuple.Create(tup.Value, tup.Key)));
// Current assignment: set of true constants
// Initially: everything is true
var assignment = new HashSet <string>(CandidateConstants.Keys);
var prover = hi.prover;
var reporter = new EmptyErrorReporter();
// assert true to flush all one-time axioms, decls, etc
prover.Assert(VCExpressionGenerator.True, true);
HoudiniStats.Start("MainLoop");
// worklist algorithm
while (worklist.Any())
{
var implName = worklist.First().Item2;
worklist.Remove(worklist.First());
if (dbg)
{
Console.WriteLine("Processing " + implName);
}
prover.LogComment("Processing " + implName);
prover.Push();
var hvc = new HoudiniVC(hi.implName2StratifiedInliningInfo[implName], impls, assignment);
var openCallSites = new HashSet <StratifiedCallSite>(hvc.CallSites);
prover.Assert(hvc.vcexpr, true);
var candidates = !DualHoudini ? new HashSet <string>(hvc.constantToAssertedExpr.Keys.Where(k => assignment.Contains(k))) :
new HashSet <string>(hvc.constantToAssumedExpr.Select(t => t.Item1).Where(k => assignment.Contains(k)));
var provedTrue = new HashSet <string>();
var provedFalse = new HashSet <string>();
var idepth = Math.Max(0, CommandLineOptions.Clo.InlineDepth);
// iterate over idepth
while (true)
{
// Part 1: over-approximate
var proved = ProveCandidates(prover, hvc.constantToAssertedExpr, hvc.constantToAssumedExpr, candidates.Difference(provedTrue.Union(provedFalse)));
provedTrue.UnionWith(proved);
if (dbg)
{
Console.WriteLine("Proved {0} candiates at depth {1}", proved.Count, CommandLineOptions.Clo.InlineDepth - idepth);
}
if (idepth == 0 || openCallSites.Count == 0)
{
break;
}
// Part 2: under-approximate
prover.Push();
foreach (var cs in openCallSites)
{
prover.Assert(cs.callSiteExpr, false);
}
var remaining = candidates.Difference(provedTrue.Union(provedFalse));
proved = ProveCandidates(prover, hvc.constantToAssertedExpr, hvc.constantToAssumedExpr, remaining);
provedFalse.UnionWith(remaining.Difference(proved));
if (dbg)
{
Console.WriteLine("Disproved {0} candiates at depth {1}", remaining.Difference(proved).Count, CommandLineOptions.Clo.InlineDepth - idepth);
}
prover.Pop();
// resolved all?
if (candidates.Difference(provedTrue.Union(provedFalse)).Count == 0)
{
break;
}
// Inline one level
idepth--;
var nextOpenCallSites = new HashSet <StratifiedCallSite>();
foreach (var cs in openCallSites)
{
var callee = new HoudiniVC(hi.implName2StratifiedInliningInfo[cs.callSite.calleeName], impls, assignment);
var calleevc = cs.Attach(callee);
prover.Assert(prover.VCExprGen.Implies(cs.callSiteExpr, calleevc), true);
nextOpenCallSites.UnionWith(callee.CallSites);
}
openCallSites = nextOpenCallSites;
}
prover.Pop();
var failed = candidates.Difference(provedTrue);
assignment.ExceptWith(failed);
if (failed.Count != 0)
{
// add dependencies back into the worklist
if (!DualHoudini)
{
foreach (var caller in callgraph.Predecessors(implName))
{
worklist.Add(Tuple.Create(impl2Priority[caller], caller));
}
}
else
{
foreach (var caller in callgraph.Successors(implName))
{
worklist.Add(Tuple.Create(impl2Priority[caller], caller));
}
}
}
}
HoudiniStats.Stop("MainLoop");
hi.Close();
return(assignment);
}
public Dictionary <string, List <CommentObj> > GetNamedObjects(int N)
{
StringBuilder sbAllWords = new StringBuilder();
foreach (children child in children)
{
sbAllWords.Append(child.SubtreeText);
sbAllWords.Append(" ");
}
string[] allWords = GetAllWords(sbAllWords.ToString());
Dictionary <string, string> stemParentDictionary = GetStemParentDictionary(allWords);
List <string> namedObjects = new List <string>();
children rootNode = new children();
List <HashSet <int> > rootChildIDs = new List <HashSet <int> >();
foreach (children child in children)
{
GetChildIDHashSetList(child);
HashSet <int> currChildIDs = new HashSet <int>();
currChildIDs.Add(child.id);
foreach (var item in child.ChildIDList)
{
currChildIDs.UnionWith(item);
}
rootChildIDs.Add(currChildIDs);
}
rootNode.ChildIDList = rootChildIDs;
NodeList = new List <children>();
NodeList.Add(rootNode);
foreach (children child in children)
{
PopulateNodeList(child);
}
Dictionary <string, HashSet <int> > wordIDMapping = GetWordIDMapping();
//Dictionary<string, double> WordTreeScore = new Dictionary<string, double>();
Dictionary <string, List <children> > WordLCAList = new Dictionary <string, List <children> >();
foreach (var kvp in wordIDMapping)
{
List <children> currLCAList = new List <children>();
int numLCAs = 0;
foreach (children node in NodeList)
{
int numBranchesWithWord = 0;
foreach (var childIDBranch in node.ChildIDList)
{
if (childIDBranch.Intersect(kvp.Value).Count() > 0)
{
numBranchesWithWord += 1;
}
}
if ((numBranchesWithWord == 1 && node.ChildIDList.Count == 1) || numBranchesWithWord > 1)
{
currLCAList.Add(node);
}
}
WordLCAList[stemParentDictionary.ContainsKey(kvp.Key) ? stemParentDictionary[kvp.Key] : kvp.Key] = currLCAList;
}
namedObjects = WordLCAList
.OrderByDescending(x => x.Value.Count)
.Select(x => x.Key)
.Where(y => CommonWords.GetFrequency(y) < 1)
.Where(a => char.IsUpper(a[0]))
.Where(b => b.Length > 1)
.Where(z => !(z.EndsWith("n't") || z.EndsWith("'m") || (z.EndsWith("'ll")) || (z.EndsWith("'d")) || z.EndsWith("'ve") || z.EndsWith("'re") || z.EndsWith("'s")))
.Take(N)
.ToList();
//namedObjects.Sort();
Dictionary <string, List <CommentObj> > namedObjectDictionary = new Dictionary <string, List <CommentObj> >();
foreach (string namedObject in namedObjects)
{
List <CommentObj> commentObjsForWord = new List <CommentObj>();
string stem = Stemmer.GetStem(namedObject);
HashSet <int> idsWithWord = wordIDMapping[stem];
foreach (int id in idsWithWord)
{
children child = GetNodeById(id);
CommentObj commentObj = new CommentObj()
{
Id = id, Text = child.text
};
commentObjsForWord.Add(commentObj);
}
namedObjectDictionary[namedObject] = commentObjsForWord;
}
var ordered = namedObjectDictionary.Keys.OrderByDescending(x => namedObjectDictionary[x].Count).ToList().ToDictionary(x => x, x => namedObjectDictionary[x]);
return(ordered);
}
internal void PrefetchCompositesRoleRelationTable(HashSet <Reference> associations, IRoleType roleType, HashSet <long> nestedObjectIds, HashSet <long> leafs)
{
var references = nestedObjectIds == null?this.FilterForPrefetchRoles(associations, roleType) : this.FilterForPrefetchCompositesRoles(associations, roleType, nestedObjectIds);
if (references.Count == 0)
{
return;
}
Command command;
if (!this.PrefetchCompositesRoleByRoleType.TryGetValue(roleType, out command))
{
var sql = this.Database.Mapping.ProcedureNameForPrefetchRoleByRelationType[roleType.RelationType];
command = this.Session.Connection.CreateCommand();
command.CommandText = sql;
command.CommandType = CommandType.StoredProcedure;
command.AddObjectTableParameter(references);
this.prefetchCompositesRoleByRoleType[roleType] = command;
}
else
{
command.Parameters[Mapping.ParamNameForTableType].Value = this.Database.CreateObjectTable(references);
}
var rolesByAssociation = new Dictionary <Reference, List <long> >();
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
var associationId = reader.GetInt64(0);
var associationReference = this.Session.State.ReferenceByObjectId[associationId];
var roleId = reader.GetInt64(1);
List <long> roleIds;
if (!rolesByAssociation.TryGetValue(associationReference, out roleIds))
{
roleIds = new List <long>();
rolesByAssociation[associationReference] = roleIds;
}
roleIds.Add(roleId);
}
}
var cache = this.Database.Cache;
foreach (var reference in references)
{
Roles modifiedRoles = null;
if (this.Session.State.ModifiedRolesByReference != null)
{
this.Session.State.ModifiedRolesByReference.TryGetValue(reference, out modifiedRoles);
}
if (modifiedRoles == null || !modifiedRoles.ModifiedRoleByRoleType.ContainsKey(roleType))
{
var cachedObject = cache.GetOrCreateCachedObject(reference.Class, reference.ObjectId, reference.VersionId);
List <long> roleIds;
if (rolesByAssociation.TryGetValue(reference, out roleIds))
{
cachedObject.SetValue(roleType, roleIds.ToArray());
nestedObjectIds?.UnionWith(roleIds);
if (nestedObjectIds == null)
{
leafs.UnionWith(roleIds);
}
}
else
{
cachedObject.SetValue(roleType, EmptyObjectIds);
}
}
}
}
internal ShaderCompilationContext ParseAndAnalyze(ShaderMixinSource shaderMixinSource, Xenko.Shaders.ShaderMacro[] macros, out ShaderMixinParsingResult parsingResult, out HashSet <ModuleMixinInfo> mixinsToAnalyze)
{
// Creates a parsing result
parsingResult = new ShaderMixinParsingResult();
SiliconStudio.Shaders.Parser.ShaderMacro[] macrosParser;
if (macros == null)
{
macrosParser = new SiliconStudio.Shaders.Parser.ShaderMacro[0];
}
else
{
macrosParser = new SiliconStudio.Shaders.Parser.ShaderMacro[macros.Length];
for (var i = 0; i < macros.Length; ++i)
{
macrosParser[i] = new SiliconStudio.Shaders.Parser.ShaderMacro(macros[i].Name, macros[i].Definition);
}
}
//PerformanceLogger.Start(PerformanceStage.Global);
// ----------------------------------------------------------
// Load all shaders
// ----------------------------------------------------------
lock (shaderLibrary)
{
//PerformanceLogger.Start(PerformanceStage.Loading);
mixinsToAnalyze = shaderLibrary.LoadShaderSource(shaderMixinSource, macrosParser);
//PerformanceLogger.Stop(PerformanceStage.Loading);
}
// Extract all ModuleMixinInfo and check for any errors
var allMixinInfos = new HashSet <ModuleMixinInfo>();
foreach (var moduleMixinInfo in mixinsToAnalyze)
{
allMixinInfos.UnionWith(moduleMixinInfo.MinimalContext);
}
foreach (var moduleMixinInfo in allMixinInfos)
{
moduleMixinInfo.Log.CopyTo(parsingResult);
var ast = moduleMixinInfo.MixinAst;
var shaderClassSource = moduleMixinInfo.ShaderSource as ShaderClassSource;
// If we have a ShaderClassSource and it is not an inline one, then we can store the hash sources
if (ast != null && shaderClassSource != null)
{
parsingResult.HashSources[shaderClassSource.ClassName] = ast.SourceHash;
}
}
// Return directly if there was any errors
if (parsingResult.HasErrors)
{
return(null);
}
// ----------------------------------------------------------
// Perform Type Analysis
// ----------------------------------------------------------
//PerformanceLogger.Start(PerformanceStage.TypeAnalysis);
var context = GetCompilationContext(mixinsToAnalyze, parsingResult);
//PerformanceLogger.Stop(PerformanceStage.TypeAnalysis);
// Return directly if there was any errors
if (parsingResult.HasErrors)
{
return(context);
}
lock (SemanticAnalyzerLock)
{
//PerformanceLogger.Start(PerformanceStage.SemanticAnalysis);
//SemanticPerformance.Start(SemanticStage.Global);
foreach (var mixin in mixinsToAnalyze)
{
context.Analyze(mixin);
}
//SemanticPerformance.Pause(SemanticStage.Global);
//PerformanceLogger.Stop(PerformanceStage.SemanticAnalysis);
}
return(context);
}
public async Task <IActionResult> PostInputsAsync([FromBody, Required] InputsRequest request)
{
// Validate request.
if (request.RoundId < 0 || !ModelState.IsValid)
{
return(BadRequest("Invalid request."));
}
if (request.Inputs.Count() > 7)
{
return(BadRequest("Maximum 7 inputs can be registered."));
}
using (await InputsLock.LockAsync())
{
CcjRound round = Coordinator.TryGetRound(request.RoundId);
if (round is null || round.Phase != CcjRoundPhase.InputRegistration)
{
return(NotFound("No such running round in InputRegistration. Try another round."));
}
// Do more checks.
try
{
uint256[] blindedOutputs = request.BlindedOutputScripts.ToArray();
int blindedOutputCount = blindedOutputs.Length;
int maxBlindedOutputCount = round.MixingLevels.Count();
if (blindedOutputCount > maxBlindedOutputCount)
{
return(BadRequest($"Too many blinded output was provided: {blindedOutputCount}, maximum: {maxBlindedOutputCount}."));
}
if (blindedOutputs.Distinct().Count() < blindedOutputs.Length)
{
return(BadRequest("Duplicate blinded output found."));
}
if (round.ContainsAnyBlindedOutputScript(blindedOutputs))
{
return(BadRequest("Blinded output has already been registered."));
}
if (request.ChangeOutputAddress.Network != Network)
{
// RegTest and TestNet address formats are sometimes the same.
if (Network == Network.Main)
{
return(BadRequest($"Invalid ChangeOutputAddress Network."));
}
}
var uniqueInputs = new HashSet <TxoRef>();
foreach (InputProofModel inputProof in request.Inputs)
{
if (uniqueInputs.Contains(inputProof.Input))
{
return(BadRequest("Cannot register an input twice."));
}
uniqueInputs.Add(inputProof.Input);
}
var alicesToRemove = new HashSet <Guid>();
var getTxOutResponses = new List <(InputProofModel inputModel, Task <GetTxOutResponse> getTxOutTask)>();
var batch = RpcClient.PrepareBatch();
foreach (InputProofModel inputProof in request.Inputs)
{
if (round.ContainsInput(inputProof.Input.ToOutPoint(), out List <Alice> tr))
{
alicesToRemove.UnionWith(tr.Select(x => x.UniqueId)); // Input is already registered by this alice, remove it later if all the checks are completed fine.
}
if (Coordinator.AnyRunningRoundContainsInput(inputProof.Input.ToOutPoint(), out List <Alice> tnr))
{
if (tr.Union(tnr).Count() > tr.Count())
{
return(BadRequest("Input is already registered in another round."));
}
}
OutPoint outpoint = inputProof.Input.ToOutPoint();
var bannedElem = await Coordinator.UtxoReferee.TryGetBannedAsync(outpoint, notedToo : false);
if (bannedElem != null)
{
return(BadRequest($"Input is banned from participation for {(int)bannedElem.BannedRemaining.TotalMinutes} minutes: {inputProof.Input.Index}:{inputProof.Input.TransactionId}."));
}
var txoutResponseTask = batch.GetTxOutAsync(inputProof.Input.TransactionId, (int)inputProof.Input.Index, includeMempool: true);
getTxOutResponses.Add((inputProof, txoutResponseTask));
}
// Perform all RPC request at once
var waiting = Task.WhenAll(getTxOutResponses.Select(x => x.getTxOutTask));
await batch.SendBatchAsync();
await waiting;
byte[] blindedOutputScriptHashesByte = ByteHelpers.Combine(blindedOutputs.Select(x => x.ToBytes()));
uint256 blindedOutputScriptsHash = new uint256(Hashes.SHA256(blindedOutputScriptHashesByte));
var inputs = new HashSet <Coin>();
foreach (var responses in getTxOutResponses)
{
var(inputProof, getTxOutResponseTask) = responses;
var getTxOutResponse = await getTxOutResponseTask;
// Check if inputs are unspent.
if (getTxOutResponse is null)
{
return(BadRequest($"Provided input is not unspent: {inputProof.Input.Index}:{inputProof.Input.TransactionId}."));
}
// Check if unconfirmed.
if (getTxOutResponse.Confirmations <= 0)
{
// If it spends a CJ then it may be acceptable to register.
if (!await Coordinator.ContainsCoinJoinAsync(inputProof.Input.TransactionId))
{
return(BadRequest("Provided input is neither confirmed, nor is from an unconfirmed coinjoin."));
}
// Check if mempool would accept a fake transaction created with the registered inputs.
// This will catch ascendant/descendant count and size limits for example.
var result = await RpcClient.TestMempoolAcceptAsync(new[] { new Coin(inputProof.Input.ToOutPoint(), getTxOutResponse.TxOut) });
if (!result.accept)
{
return(BadRequest($"Provided input is from an unconfirmed coinjoin, but a limit is reached: {result.rejectReason}"));
}
}
// Check if immature.
if (getTxOutResponse.Confirmations <= 100)
{
if (getTxOutResponse.IsCoinBase)
{
return(BadRequest("Provided input is immature."));
}
}
// Check if inputs are native segwit.
if (getTxOutResponse.ScriptPubKeyType != "witness_v0_keyhash")
{
return(BadRequest("Provided input must be witness_v0_keyhash."));
}
TxOut txout = getTxOutResponse.TxOut;
var address = (BitcoinWitPubKeyAddress)txout.ScriptPubKey.GetDestinationAddress(Network);
// Check if proofs are valid.
if (!address.VerifyMessage(blindedOutputScriptsHash, inputProof.Proof))
{
return(BadRequest("Provided proof is invalid."));
}
inputs.Add(new Coin(inputProof.Input.ToOutPoint(), txout));
}
var acceptedBlindedOutputScripts = new List <uint256>();
// Calculate expected networkfee to pay after base denomination.
int inputCount = inputs.Count();
Money networkFeeToPayAfterBaseDenomination = (inputCount * round.FeePerInputs) + (2 * round.FeePerOutputs);
// Check if inputs have enough coins.
Money inputSum = inputs.Sum(x => x.Amount);
Money changeAmount = (inputSum - (round.MixingLevels.GetBaseDenomination() + networkFeeToPayAfterBaseDenomination));
if (changeAmount < Money.Zero)
{
return(BadRequest($"Not enough inputs are provided. Fee to pay: {networkFeeToPayAfterBaseDenomination.ToString(false, true)} BTC. Round denomination: {round.MixingLevels.GetBaseDenomination().ToString(false, true)} BTC. Only provided: {inputSum.ToString(false, true)} BTC."));
}
acceptedBlindedOutputScripts.Add(blindedOutputs.First());
Money networkFeeToPay = networkFeeToPayAfterBaseDenomination;
// Make sure we sign the proper number of additional blinded outputs.
var moneySoFar = Money.Zero;
for (int i = 1; i < blindedOutputCount; i++)
{
if (!round.MixingLevels.TryGetDenomination(i, out Money denomination))
{
break;
}
Money coordinatorFee = denomination.Percentage(round.CoordinatorFeePercent * round.AnonymitySet); // It should be the number of bobs, but we must make sure they'd have money to pay all.
changeAmount -= (denomination + round.FeePerOutputs + coordinatorFee);
networkFeeToPay += round.FeePerOutputs;
if (changeAmount < Money.Zero)
{
break;
}
acceptedBlindedOutputScripts.Add(blindedOutputs[i]);
}
// Make sure Alice checks work.
var alice = new Alice(inputs, networkFeeToPayAfterBaseDenomination, request.ChangeOutputAddress, acceptedBlindedOutputScripts);
foreach (Guid aliceToRemove in alicesToRemove)
{
round.RemoveAlicesBy(aliceToRemove);
}
round.AddAlice(alice);
// All checks are good. Sign.
var blindSignatures = new List <uint256>();
for (int i = 0; i < acceptedBlindedOutputScripts.Count; i++)
{
var blindedOutput = acceptedBlindedOutputScripts[i];
var signer = round.MixingLevels.GetLevel(i).Signer;
uint256 blindSignature = signer.Sign(blindedOutput);
blindSignatures.Add(blindSignature);
}
alice.BlindedOutputSignatures = blindSignatures.ToArray();
// Check if phase changed since.
if (round.Status != CcjRoundStatus.Running || round.Phase != CcjRoundPhase.InputRegistration)
{
return(StatusCode(StatusCodes.Status503ServiceUnavailable, "The state of the round changed while handling the request. Try again."));
}
// Progress round if needed.
if (round.CountAlices() >= round.AnonymitySet)
{
await round.RemoveAlicesIfAnInputRefusedByMempoolAsync();
if (round.CountAlices() >= round.AnonymitySet)
{
await round.ExecuteNextPhaseAsync(CcjRoundPhase.ConnectionConfirmation);
}
}
var resp = new InputsResponse {
UniqueId = alice.UniqueId,
RoundId = round.RoundId
};
return(Ok(resp));
}
catch (Exception ex)
{
Logger.LogDebug <ChaumianCoinJoinController>(ex);
return(BadRequest(ex.Message));
}
}
}
public static void GenerateDependencies(string strippedAssemblyDir, string icallsListFile, RuntimeClassRegistry rcr, bool doStripping, out HashSet <UnityType> nativeClasses, out HashSet <string> nativeModules, IIl2CppPlatformProvider platformProvider)
{
if (AssemblyStripper.UseUnityLinkerEngineModuleStripping)
{
GenerateDependencies2(strippedAssemblyDir, doStripping, out nativeClasses, out nativeModules);
return;
}
var strippingInfo = platformProvider == null ? null : StrippingInfo.GetBuildReportData(platformProvider.buildReport);
var userAssemblies = GetUserAssemblies(strippedAssemblyDir);
// [1] Extract native classes from scene and scripts
nativeClasses = doStripping ? GenerateNativeClassList(rcr, strippedAssemblyDir, userAssemblies, strippingInfo) : null;
// Exclude module managers (GlobalGameManager) if no dependent classes are used.
if (nativeClasses != null)
{
ExcludeModuleManagers(ref nativeClasses);
}
// [2] Prepare a list of modules to register
nativeModules = GetNativeModulesToRegister(nativeClasses, strippingInfo);
if (nativeClasses != null && icallsListFile != null)
{
// Get required modules from icall list file
var icallModules = GetModulesFromICalls(icallsListFile);
// Add GameManager classes for modules
foreach (var module in icallModules)
{
if (!nativeModules.Contains(module))
{
if (strippingInfo != null)
{
strippingInfo.RegisterDependency(StrippingInfo.ModuleName(module), StrippingInfo.RequiredByScripts);
}
}
var moduleClasses = ModuleMetadata.GetModuleTypes(module);
foreach (var klass in moduleClasses)
{
if (klass.IsDerivedFrom(GameManagerTypeInfo))
{
nativeClasses.Add(klass);
}
}
}
nativeModules.UnionWith(icallModules);
}
ApplyManualStrippingOverrides(nativeClasses, nativeModules, strippingInfo);
bool didAdd = true;
if (platformProvider != null)
{
while (didAdd)
{
didAdd = false;
foreach (var module in nativeModules.ToList())
{
var dependecies = ModuleMetadata.GetModuleDependencies(module);
foreach (var dependentModule in dependecies)
{
if (!nativeModules.Contains(dependentModule))
{
nativeModules.Add(dependentModule);
didAdd = true;
}
if (strippingInfo != null)
{
var moduleName = StrippingInfo.ModuleName(module);
strippingInfo.RegisterDependency(StrippingInfo.ModuleName(dependentModule), "Required by " + moduleName);
strippingInfo.SetIcon("Required by " + moduleName, $"package/com.unity.modules.{module.ToLower()}");
}
}
}
}
}
if (nativeClasses != null)
{
RemoveClassesFromRemovedModules(nativeClasses, nativeModules);
}
AssemblyReferenceChecker checker = new AssemblyReferenceChecker();
checker.CollectReferencesFromRoots(strippedAssemblyDir, userAssemblies, true, 0.0f, true);
if (strippingInfo != null)
{
foreach (var module in nativeModules)
{
strippingInfo.AddModule(module);
}
strippingInfo.AddModule("Core");
}
if (nativeClasses != null && strippingInfo != null && platformProvider != null)
{
InjectCustomDependencies(platformProvider.target, strippingInfo, nativeClasses, nativeModules);
}
}
/// <summary>
/// Get an list of languages that match the given string in some way (code, name, country)
/// </summary>
public IEnumerable<LanguageInfo> SuggestLanguages(string searchString)
{
if (searchString != null)
searchString = searchString.Trim();
if (string.IsNullOrEmpty(searchString))
yield break;
if (searchString == "*")
{
// there will be duplicate LanguageInfo entries for 2 and 3 letter codes and equivalent tags
var all_languages = new HashSet<LanguageInfo>(_codeToLanguageIndex.Select(l => l.Value));
foreach (LanguageInfo languageInfo in all_languages.OrderBy(l => l, new ResultComparer(searchString)))
yield return languageInfo;
}
// if the search string exactly matches a hard-coded way to say "sign", show all the sign languages
// there will be duplicate LanguageInfo entries for equivalent tags
else if (new []{"sign", "sign language","signes", "langage des signes", "señas","lenguaje de señas"}.Contains(searchString.ToLowerInvariant()))
{
var parallelSearch = new HashSet<LanguageInfo>(_codeToLanguageIndex.AsParallel().Select(li => li.Value).Where(l =>
l.Names.AsQueryable().Any(n => n.ToLowerInvariant().Contains("sign"))));
foreach (LanguageInfo languageInfo in parallelSearch)
{
yield return languageInfo;
}
}
else
{
IEnumerable<LanguageInfo> matchOnCode = from x in _codeToLanguageIndex where x.Key.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase) select x.Value;
List<LanguageInfo>[] matchOnName = (from x in _nameToLanguageIndex where x.Key.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase) select x.Value).ToArray();
// Apostrophes can cause trouble in lookup. Unicode TR-29 inexplicably says to use
// u2019 (RIGHT SINGLE QUOTATION MARK) for the English apostrophe when it also defines
// u02BC (MODIFIER LETTER APOSTROPHE) as a Letter character. Users are quite likely to
// type the ASCII apostrophe (u0027) which is defined as Punctuation. The current
// data appears to use u2019 in several language names, which means that users might
// end up thinking the language isn't in our database.
// See https://silbloom.myjetbrains.com/youtrack/issue/BL-6339.
if (!matchOnName.Any() && searchString.Contains('\''))
{
searchString = searchString.Replace('\'','\u2019');
matchOnName = (from x in _nameToLanguageIndex where x.Key.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase) select x.Value).ToArray();
}
List<LanguageInfo>[] matchOnCountry = (from x in _countryToLanguageIndex where x.Key.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase) select x.Value).ToArray();
if (!matchOnName.Any())
{
// look for approximate matches
const int kMaxEditDistance = 3;
var itemFormExtractor = new ApproximateMatcher.GetStringDelegate<KeyValuePair<string, List<LanguageInfo>>>(pair => pair.Key);
IList<KeyValuePair<string, List<LanguageInfo>>> matches = ApproximateMatcher.FindClosestForms(_nameToLanguageIndex, itemFormExtractor,
searchString,
ApproximateMatcherOptions.None,
kMaxEditDistance);
matchOnName = (from m in matches select m.Value).ToArray();
}
var combined = new HashSet<LanguageInfo>(matchOnCode);
foreach (List<LanguageInfo> l in matchOnName)
combined.UnionWith(l);
foreach (List<LanguageInfo> l in matchOnCountry)
combined.UnionWith(l);
var ordered = combined.OrderBy(l => l, new ResultComparer(searchString));
foreach (LanguageInfo languageInfo in ordered)
yield return languageInfo;
}
}
public void UpdateReachableTransitions(string newThing = null, bool item = false, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
if (newThing == null)
{
newThing = Randomizer.startTransition;
}
Queue <string> updates = new Queue <string>();
if (!item)
{
reachableTransitions.Add(newThing);
}
pm.Add(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
if (transitionPlacements.TryGetValue(next, out string next2) && !reachableTransitions.Contains(next2))
{
reachableTransitions.Add(next2);
pm.Add(next2);
updates.Enqueue(next2);
}
HashSet <string> potentialTransitions = LogicManager.GetTransitionsByProgression(recentProgression);
// update possible vanilla locations
HashSet <string> potentialLocations = LogicManager.GetLocationsByProgression(recentProgression);
potentialLocations.IntersectWith(vanillaProgression);
if (potentialLocations.Any())
{
checkProgression.UnionWith(potentialLocations);
vanillaProgression.ExceptWith(checkProgression);
}
recentProgression = new HashSet <string>();
foreach (string transition in potentialTransitions)
{
if (!reachableTransitions.Contains(transition) && pm.CanGet(transition))
{
reachableTransitions.Add(transition);
pm.Add(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachableTransitions.Add(transition2);
pm.Add(transition2);
updates.Enqueue(transition2);
}
}
}
if (!updates.Any()) // vanilla locations are very unlikely to enter into logic, so we only check them right before the loop ends
{
List <string> iterate = new List <string>();
foreach (string loc in checkProgression)
{
if (pm.CanGet(loc))
{
pm.Add(loc);
iterate.Add(loc); // **Don't**modify**collection**while**iterating**
updates.Enqueue(loc);
}
}
checkProgression.ExceptWith(iterate);
}
}
}
/// <summary>
/// Merges the given <paramref name="other" /> CardinalityEstimator instance into this one
/// </summary>
/// <param name="other">another instance of CardinalityEstimator</param>
public void Merge(CardinalityEstimator other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
if (other._m != this._m)
{
throw new ArgumentOutOfRangeException(nameof(other),
"Cannot merge CardinalityEstimator instances with different accuracy/map sizes");
}
this.CountAdditions += other.CountAdditions;
if (this._isSparse && other._isSparse)
{
// Merge two sparse instances
foreach (KeyValuePair <ushort, byte> kvp in other._lookupSparse)
{
ushort index = kvp.Key;
byte otherRank = kvp.Value;
byte thisRank;
this._lookupSparse.TryGetValue(index, out thisRank);
this._lookupSparse[index] = Math.Max(thisRank, otherRank);
}
// Switch to dense if necessary
if (this._lookupSparse.Count > this._sparseMaxElements)
{
SwitchToDenseRepresentation();
}
}
else
{
// Make sure this (target) instance is dense, then merge
SwitchToDenseRepresentation();
if (other._isSparse)
{
foreach (KeyValuePair <ushort, byte> kvp in other._lookupSparse)
{
ushort index = kvp.Key;
byte rank = kvp.Value;
this._lookupDense[index] = Math.Max(this._lookupDense[index], rank);
}
}
else
{
for (var i = 0; i < this._m; i++)
{
this._lookupDense[i] = Math.Max(this._lookupDense[i], other._lookupDense[i]);
}
}
}
if (other._directCount != null)
{
// Other instance is using direct counter. If this instance is also using direct counter, merge them.
_directCount?.UnionWith(other._directCount);
}
else
{
// Other instance is not using direct counter, make sure this instance doesn't either
this._directCount = null;
}
}
private ValidationResult ValidateInternal(string[] ruleSets)
{
var result = new ValidationResult {
IsValid = true
};
var binderPropsOrFieldsOfT = this.TypeProperties.Keys;
foreach (var rule in ruleSets)
{
if (this.StrictModes.TryGetValue(rule, out var strictMode))
{
}
else
{
strictMode = Faker.DefaultStrictMode;
}
//If strictMode is not enabled, skip and move on to the next ruleSet.
if (!strictMode)
{
continue;
}
this.Actions.TryGetValue(rule, out var populateActions);
var userSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
if (populateActions != null)
{
userSet.UnionWith(populateActions.Keys);
}
//Get the set properties or fields that are only
//known to the binder, while removing
//items in userSet that are known to both the user and binder.
userSet.SymmetricExceptWith(binderPropsOrFieldsOfT);
//What's left in userSet is the set of properties or fields
//that the user does not know about + .Rule() methods.
if (userSet.Count > 0)
{
foreach (var propOrFieldOfT in userSet)
{
if (populateActions is not null && populateActions.TryGetValue(propOrFieldOfT, out var populateAction))
{
// Very much a .Rules() action
if (populateAction.ProhibitInStrictMode)
{
result.ExtraMessages.Add(
$"When StrictMode is set to True the Faker<{typeof(T).Name}>.Rules(...) method cannot verify that all properties have rules. You need to use Faker<{typeof(T).Name}>.RuleFor( x => x.Prop, ...) for each property to ensure each property has an associated rule when StrictMode is true; otherwise, set StrictMode to False in order to use Faker<{typeof(T).Name}>.Rules() method.");
result.IsValid = false;
}
}
else //The user doesn't know about this property or field. Log it as a validation error.
{
result.MissingRules.Add(propOrFieldOfT);
result.IsValid = false;
}
}
}
public void BuildNodeSets(TreeNode node)
{
if (node == null)
{
return;
}
node.FollowPos = new HashSet <TreeNode>();
switch (node.Type)
{
case NodeType.Epsilon:
node.Nullable = true;
node.FirstPos = new HashSet <TreeNode>();
node.LastPos = new HashSet <TreeNode>();
break;
case NodeType.Cut:
BuildNodeSets(node.Left);
BuildNodeSets(node.Right);
node.Nullable = node.Left.Nullable && node.Right.Nullable;
var setcu = new HashSet <TreeNode>(node.Left.FirstPos);
if (node.Left.Nullable)
{
setcu.UnionWith(node.Right.FirstPos);
}
node.FirstPos = setcu;
setcu = new HashSet <TreeNode>(node.Right.LastPos);
if (node.Right.Nullable)
{
setcu.UnionWith(node.Left.LastPos);
}
node.LastPos = setcu;
foreach (var n in node.Right.FirstPos)
{
n.Starts = true;
}
foreach (var i in node.Left.LastPos)
{
i.FollowPos.UnionWith(node.Right.FirstPos);
}
break;
case NodeType.Star:
BuildNodeSets(node.Left);
node.Nullable = true;
node.FirstPos = new HashSet <TreeNode>(node.Left.FirstPos);
node.LastPos = new HashSet <TreeNode>(node.Left.LastPos);
foreach (var i in node.Left.LastPos)
{
i.FollowPos.UnionWith(node.FirstPos);
}
break;
case NodeType.Plus:
BuildNodeSets(node.Left);
node.Nullable = node.Left.Nullable;
node.FirstPos = new HashSet <TreeNode>(node.Left.FirstPos);
node.LastPos = new HashSet <TreeNode>(node.Left.LastPos);
foreach (var i in node.Left.LastPos)
{
i.FollowPos.UnionWith(node.FirstPos);
}
break;
case NodeType.Or:
BuildNodeSets(node.Left);
BuildNodeSets(node.Right);
node.Nullable = node.Left.Nullable | node.Right.Nullable;
var set = new HashSet <TreeNode>(node.Left.FirstPos);
set.UnionWith(node.Left.FirstPos);
node.FirstPos = set;
set = new HashSet <TreeNode>(node.Left.LastPos);
set.UnionWith(node.Left.LastPos);
node.LastPos = set;
break;
case NodeType.Cat:
BuildNodeSets(node.Left);
BuildNodeSets(node.Right);
node.Nullable = node.Left.Nullable & node.Right.Nullable;
var setc = new HashSet <TreeNode>(node.Left.FirstPos);
if (node.Left.Nullable)
{
setc.UnionWith(node.Right.FirstPos);
}
node.FirstPos = setc;
setc = new HashSet <TreeNode>(node.Right.LastPos);
if (node.Right.Nullable)
{
setc.UnionWith(node.Left.LastPos);
}
node.LastPos = setc;
foreach (var i in node.Left.LastPos)
{
i.FollowPos.UnionWith(node.Right.FirstPos);
}
break;
default:
// A regular character.
node.Nullable = false;
node.FirstPos = new HashSet <TreeNode> {
node
};
node.LastPos = new HashSet <TreeNode> {
node
};
break;
}
}
/// <summary>
/// Validates property mappings.
/// </summary>
/// <param name="model"> The model. </param>
/// <param name="logger"> The logger to use. </param>
protected virtual void ValidatePropertyMapping([NotNull] IModel model, [NotNull] IDiagnosticsLogger <DbLoggerCategory.Model.Validation> logger)
{
Check.NotNull(model, nameof(model));
if (!(model is IConventionModel conventionModel))
{
return;
}
foreach (var entityType in conventionModel.GetEntityTypes())
{
var unmappedProperty = entityType.GetProperties().FirstOrDefault(
p => (!ConfigurationSource.Convention.Overrides(p.GetConfigurationSource()) ||
!p.IsShadowProperty()) &&
p.FindTypeMapping() == null);
if (unmappedProperty != null)
{
throw new InvalidOperationException(
CoreStrings.PropertyNotMapped(
entityType.DisplayName(), unmappedProperty.Name, unmappedProperty.ClrType.ShortDisplayName()));
}
if (!entityType.HasClrType())
{
continue;
}
var clrProperties = new HashSet <string>(StringComparer.Ordinal);
var runtimeProperties = entityType.AsEntityType().GetRuntimeProperties();
clrProperties.UnionWith(
runtimeProperties.Values
.Where(pi => pi.IsCandidateProperty())
.Select(pi => pi.GetSimpleMemberName()));
clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name));
clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name));
clrProperties.ExceptWith(entityType.GetServiceProperties().Select(p => p.Name));
clrProperties.RemoveWhere(p => entityType.FindIgnoredConfigurationSource(p) != null);
if (clrProperties.Count <= 0)
{
continue;
}
foreach (var clrProperty in clrProperties)
{
var actualProperty = runtimeProperties[clrProperty];
var propertyType = actualProperty.PropertyType;
var targetSequenceType = propertyType.TryGetSequenceType();
if (conventionModel.FindIgnoredConfigurationSource(propertyType.DisplayName()) != null ||
targetSequenceType != null &&
conventionModel.FindIgnoredConfigurationSource(targetSequenceType.DisplayName()) != null)
{
continue;
}
var targetType = FindCandidateNavigationPropertyType(actualProperty);
var isTargetWeakOrOwned
= targetType != null &&
(conventionModel.HasEntityTypeWithDefiningNavigation(targetType) ||
conventionModel.IsOwned(targetType));
if (targetType?.IsValidEntityType() == true &&
(isTargetWeakOrOwned ||
conventionModel.FindEntityType(targetType) != null ||
targetType.GetRuntimeProperties().Any(p => p.IsCandidateProperty())))
{
// ReSharper disable CheckForReferenceEqualityInstead.1
// ReSharper disable CheckForReferenceEqualityInstead.3
if ((!entityType.IsKeyless ||
targetSequenceType == null) &&
entityType.GetDerivedTypes().All(
dt => dt.GetDeclaredNavigations().FirstOrDefault(n => n.Name == actualProperty.GetSimpleMemberName()) == null) &&
(!isTargetWeakOrOwned ||
(!targetType.Equals(entityType.ClrType) &&
(!entityType.IsInOwnershipPath(targetType) ||
(entityType.FindOwnership().PrincipalEntityType.ClrType.Equals(targetType) &&
targetSequenceType == null)) &&
(!entityType.IsInDefinitionPath(targetType) ||
(entityType.DefiningEntityType.ClrType.Equals(targetType) &&
targetSequenceType == null)))))
{
if (conventionModel.IsOwned(entityType.ClrType) &&
conventionModel.IsOwned(targetType))
{
throw new InvalidOperationException(
CoreStrings.AmbiguousOwnedNavigation(entityType.ClrType.ShortDisplayName(), targetType.ShortDisplayName()));
}
throw new InvalidOperationException(
CoreStrings.NavigationNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
// ReSharper restore CheckForReferenceEqualityInstead.3
// ReSharper restore CheckForReferenceEqualityInstead.1
}
else if (targetSequenceType == null && propertyType.GetTypeInfo().IsInterface ||
targetSequenceType?.GetTypeInfo().IsInterface == true)
{
throw new InvalidOperationException(
CoreStrings.InterfacePropertyNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
else
{
throw new InvalidOperationException(
CoreStrings.PropertyNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
}
}
}
private void WatchThread(CancellationToken token)
{
for (; ;)
{
var searchItems = new List <SearchListViewItemInfo>();
{
var seedInfos = new HashSet <(Seed, Signature)>();
var storeMetadatas = new HashSet <Metadata>();
var cacheMetadatas = new HashSet <Metadata>();
var downloadingMetadatas = new HashSet <Metadata>();
var downloadedMetadatas = new HashSet <Metadata>();
foreach (var store in _messageManager.GetStores())
{
var seedHashSet = new HashSet <Seed>();
{
var boxList = new List <Box>();
boxList.AddRange(store.Value.Boxes);
for (int i = 0; i < boxList.Count; i++)
{
boxList.AddRange(boxList[i].Boxes);
seedHashSet.UnionWith(boxList[i].Seeds);
}
}
foreach (var seed in seedHashSet)
{
seedInfos.Add((seed, store.AuthorSignature));
storeMetadatas.Add(seed.Metadata);
}
}
{
var signature = SettingsManager.Instance.AccountInfo.DigitalSignature.GetSignature();
foreach (var seed in _serviceManager.GetCacheContentReports()
.Select(n => new Seed(Path.GetFileName(n.Path), n.Length, n.CreationTime, n.Metadata)).ToArray())
{
seedInfos.Add((seed, signature));
cacheMetadatas.Add(seed.Metadata);
}
}
downloadingMetadatas.UnionWith(_serviceManager.GetDownloadContentReports().Select(n => n.Metadata));
{
var downloadedSeeds = SettingsManager.Instance.DownloadedSeeds.ToArray();
foreach (var seed in SettingsManager.Instance.DownloadedSeeds.ToArray())
{
if (!storeMetadatas.Contains(seed.Metadata) && !cacheMetadatas.Contains(seed.Metadata))
{
seedInfos.Add((seed, null));
}
downloadedMetadatas.Add(seed.Metadata);
}
}
foreach (var(seed, signature) in seedInfos)
{
var viewModel = new SearchListViewItemInfo();
viewModel.Icon = IconUtils.GetImage(seed.Name);
viewModel.Name = seed.Name;
viewModel.Signature = signature;
viewModel.Length = seed.Length;
viewModel.CreationTime = seed.CreationTime;
SearchState state = 0;
if (storeMetadatas.Contains(seed.Metadata))
{
state |= SearchState.Store;
}
if (cacheMetadatas.Contains(seed.Metadata))
{
state |= SearchState.Cache;
}
if (downloadingMetadatas.Contains(seed.Metadata))
{
state |= SearchState.Downloading;
}
if (downloadedMetadatas.Contains(seed.Metadata))
{
state |= SearchState.Downloaded;
}
viewModel.State = state;
viewModel.Model = seed;
searchItems.Add(viewModel);
}
}
lock (_cache_SearchItems.LockObject)
{
_cache_SearchItems.Clear();
_cache_SearchItems.AddRange(searchItems);
}
this.SetCount(this.TabViewModel.Value, searchItems, token);
if (token.WaitHandle.WaitOne(1000 * 20))
{
return;
}
}
}
protected override void OnReceive(AbstractMessage message)
{
TypeSwitch.On(message)
.Case((CoordinatorMessage coordinatorMessage) =>
{
k_max = 0;
partition = new Dictionary <TNode, int>();
oldNumBlocks = 0;
blocks = new HashSet <int>();
workers = coordinatorMessage.Workers;
state = new Dictionary <AbstractMachine, WorkerState>();
foreach (var worker in workers)
{
state.Add(worker, WorkerState.Refining);
worker.SendMe(new ClearMessage(this));
}
})
.Case((EstimateRefinedMessage refinedMessage) =>
{
state[refinedMessage.Sender] = WorkerState.Waiting;
if (workers.All(worker => state[worker] == WorkerState.Waiting))
{
// All workers have refined, now perform a share step
foreach (var worker in workers)
{
state[worker] = WorkerState.Sharing;
worker.SendMe(new ShareMessage(this));
}
}
})
.Case((SharedMessage sharedMessage) =>
{
state[sharedMessage.Sender] = WorkerState.Waiting;
if (workers.All(worker => state[worker] == WorkerState.Waiting))
{
// All workers have shared, now count the number of unqiue blocks
oldNumBlocks = blocks.Count;
blocks.Clear();
foreach (var worker in workers)
{
state[worker] = WorkerState.Counting;
worker.SendMe(new CountMessage(this));
}
}
})
.Case((CountedMessage countedMessage) =>
{
state[countedMessage.Sender] = WorkerState.Waiting;
blocks.UnionWith(countedMessage.Blocks);
if (workers.All(worker => state[worker] == WorkerState.Waiting))
{
if (blocks.Count > oldNumBlocks)
{
// There was a change, continue refining
k_max += 1;
foreach (var worker in workers)
{
state[worker] = WorkerState.Refining;
worker.SendMe(new RefineMessage(this));
}
}
else
{
// We're done, collect global partition
k_max -= 1;
foreach (var worker in workers)
{
state[worker] = WorkerState.Collecting;
worker.SendMe(new SegmentRequestMessage(this));
}
}
}
})
.Case((SegmentResponseMessage <TNode> segmentResponseMessage) =>
{
state[segmentResponseMessage.Sender] = WorkerState.Waiting;
foreach (var pair in segmentResponseMessage.Pairs)
{
partition.Add(pair.Key, pair.Value);
}
if (workers.All(worker => state[worker] == WorkerState.Waiting))
{
onComplete(k_max, partition);
}
});
}
public List <string> GetAnchorWords(int N)
{
StringBuilder sbAllWords = new StringBuilder();
foreach (children child in children)
{
sbAllWords.Append(child.SubtreeText);
sbAllWords.Append(" ");
}
string[] allWords = GetAllWords(sbAllWords.ToString());
Dictionary <string, string> stemParentDictionary = GetStemParentDictionary(allWords);
List <string> anchorWords = new List <string>();
children rootNode = new children();
List <HashSet <int> > rootChildIDs = new List <HashSet <int> >();
foreach (children child in children)
{
GetChildIDHashSetList(child);
HashSet <int> currChildIDs = new HashSet <int>();
currChildIDs.Add(child.id);
foreach (var item in child.ChildIDList)
{
currChildIDs.UnionWith(item);
}
rootChildIDs.Add(currChildIDs);
}
rootNode.ChildIDList = rootChildIDs;
NodeList = new List <children>();
NodeList.Add(rootNode);
foreach (children child in children)
{
PopulateNodeList(child);
}
Dictionary <string, HashSet <int> > wordIDMapping = GetWordIDMapping();
//Dictionary<string, double> WordTreeScore = new Dictionary<string, double>();
Dictionary <string, List <children> > WordLCAList = new Dictionary <string, List <children> >();
foreach (var kvp in wordIDMapping)
{
List <children> currLCAList = new List <children>();
int numLCAs = 0;
foreach (children node in NodeList)
{
int numBranchesWithWord = 0;
foreach (var childIDBranch in node.ChildIDList)
{
if (childIDBranch.Intersect(kvp.Value).Count() > 0)
{
numBranchesWithWord += 1;
}
}
if ((numBranchesWithWord == 1 && node.ChildIDList.Count == 1) || numBranchesWithWord > 1)
{
currLCAList.Add(node);
}
}
WordLCAList[stemParentDictionary.ContainsKey(kvp.Key)? stemParentDictionary[kvp.Key]:kvp.Key] = currLCAList;
}
anchorWords = WordLCAList
.OrderByDescending(x => x.Value.Count)
.Select(x => x.Key)
.Where(y => CommonWords.GetFrequency(y) < 20)
.Where(z => !(z.EndsWith("n't") || z.EndsWith("'m") || (z.EndsWith("'ll")) || (z.EndsWith("'d")) || z.EndsWith("'ve") || z.EndsWith("'re") || z.EndsWith("'s")))
.Take(N)
.ToList();
return(anchorWords);
}
static LocalNode()
{
LocalAddresses.UnionWith(NetworkInterface.GetAllNetworkInterfaces().SelectMany(p => p.GetIPProperties().UnicastAddresses).Select(p => p.Address.MapToIPv6()));
}
// Prove candidates that hold (using an over-approximation, at the current inline depth).
// Return the set of candidates proved correct
static HashSet <string> ProveCandidates(ProverInterface prover, Dictionary <string, VCExpr> constantToAssertedExpr, List <Tuple <string, VCExpr, VCExpr> > constantToAssumedExpr, HashSet <string> candidates)
{
var remaining = new HashSet <string>(candidates);
var reporter = new EmptyErrorReporter();
var failed = new HashSet <string>();
// for dual houdini, we have to iterate once around to the loop
// even if remaining is empty
bool secondtry = false;
while (true)
{
remaining.ExceptWith(failed);
if (remaining.Count == 0 && (!DualHoudini || secondtry))
{
break;
}
if (remaining.Count == 0)
{
secondtry = true;
}
else
{
secondtry = false;
}
HoudiniStats.ProverCount++;
HoudiniStats.Start("ProverTime");
prover.Push();
var nameToCallSiteVar = new Dictionary <string, VCExprVar>();
var callSiteVarToConstantToExpr = new Dictionary <string, Dictionary <string, VCExpr> >();
if (!DualHoudini)
{
// assert post
VCExpr toassert = VCExpressionGenerator.True;
foreach (var k in remaining)
{
toassert = prover.VCExprGen.And(toassert, constantToAssertedExpr[k]);
}
prover.Assert(toassert, false);
}
else
{
// assume post of callees
foreach (var tup in constantToAssumedExpr)
{
if (!remaining.Contains(tup.Item1))
{
continue;
}
var csVar = tup.Item2 as VCExprVar;
Debug.Assert(csVar != null);
if (!nameToCallSiteVar.ContainsKey(csVar.ToString()))
{
nameToCallSiteVar.Add(csVar.ToString(), csVar);
}
if (!callSiteVarToConstantToExpr.ContainsKey(csVar.ToString()))
{
callSiteVarToConstantToExpr.Add(csVar.ToString(), new Dictionary <string, VCExpr>());
}
callSiteVarToConstantToExpr[csVar.ToString()].Add(tup.Item1, tup.Item3);
}
foreach (var tup in callSiteVarToConstantToExpr)
{
var expr = VCExpressionGenerator.False;
tup.Value.Values.Iter(e => expr = prover.VCExprGen.Or(expr, e));
prover.Assert(prover.VCExprGen.Implies(nameToCallSiteVar[tup.Key], expr), true);
}
}
Dictionary <string, VCExprVar> recordingBool = null;
if (RobustAgainstEvaluate)
{
recordingBool = new Dictionary <string, VCExprVar>();
VCExpr torecord = VCExpressionGenerator.True;
foreach (var k in remaining)
{
var b = prover.VCExprGen.Variable("recordingVar_" + k, Microsoft.Boogie.Type.Bool);
recordingBool.Add(k, b);
torecord = prover.VCExprGen.And(torecord, prover.VCExprGen.Eq(b, constantToAssertedExpr[k]));
}
prover.Assert(torecord, true);
}
prover.Check();
var outcome = prover.CheckOutcomeCore(reporter);
// check which ones failed
if (outcome == ProverInterface.Outcome.Invalid || outcome == ProverInterface.Outcome.Undetermined)
{
var removed = 0;
if (!DualHoudini)
{
foreach (var k in remaining)
{
var b = recordingBool == null ? (bool)prover.Evaluate(constantToAssertedExpr[k])
: (bool)prover.Evaluate(recordingBool[k]);
if (!b)
{
failed.Add(k);
if (dbg)
{
Console.WriteLine("Failed: {0}", k);
}
removed++;
}
}
}
else
{
foreach (var tup in callSiteVarToConstantToExpr)
{
if (!(bool)prover.Evaluate(nameToCallSiteVar[tup.Key]))
{
continue;
}
// call site taken
foreach (var tup2 in tup.Value)
{
if ((bool)prover.Evaluate(tup2.Value))
{
failed.Add(tup2.Key);
if (dbg)
{
Console.WriteLine("Failed: {0}", tup2.Key);
}
removed++;
}
}
}
if (removed == 0)
{
throw new DualHoudiniFail("Nothing to drop");
}
}
Debug.Assert(removed != 0);
//if(dbg) Console.WriteLine("Query {0}: Invalid, {1} removed", HoudiniStats.ProverCount, removed);
}
HoudiniStats.Stop("ProverTime");
prover.Pop();
if (outcome == ProverInterface.Outcome.TimeOut || outcome == ProverInterface.Outcome.OutOfMemory)
{
if (DualHoudini)
{
throw new DualHoudiniFail("Timeout");
}
failed.UnionWith(remaining);
break;
}
if (outcome == ProverInterface.Outcome.Valid)
{
//if(dbg) Console.WriteLine("Query {0}: Valid", HoudiniStats.ProverCount);
break;
}
}
remaining.ExceptWith(failed);
return(remaining);
}
static void LoadLegacyExtensionsFromIvyFiles()
{
//We can't use the cached native type scanner here since this is called to early for that to be built up.
HashSet <string> ivyFiles;
try
{
ivyFiles = new HashSet <string>();
string unityExtensionsFolder = FileUtil.CombinePaths(Directory.GetParent(EditorApplication.applicationPath).ToString(), "Data", "UnityExtensions");
string playbackEngineFolders = FileUtil.CombinePaths(Directory.GetParent(EditorApplication.applicationPath).ToString(), "PlaybackEngines");
foreach (var searchPath in new[]
{
FileUtil.NiceWinPath(EditorApplication.applicationContentsPath),
FileUtil.NiceWinPath(unityExtensionsFolder),
FileUtil.NiceWinPath(playbackEngineFolders)
})
{
if (!Directory.Exists(searchPath))
{
continue;
}
ivyFiles.UnionWith(Directory.GetFiles(searchPath, "ivy.xml", SearchOption.AllDirectories));
}
}
catch (Exception ex)
{
Console.WriteLine("Error scanning for extension ivy.xml files: {0}", ex);
return;
}
var packages = new Dictionary <string, List <IvyPackageFileData> >();
var artifactRegex = new Regex(@"<artifact(\s+(name=""(?<name>[^""]*)""|type=""(?<type>[^""]*)""|ext=""(?<ext>[^""]*)""|e:guid=""(?<guid>[^""]*)""))+\s*/>",
RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);
foreach (var ivyFile in ivyFiles)
{
try
{
var ivyFileContent = File.ReadAllText(ivyFile);
var artifacts = artifactRegex.Matches(ivyFileContent).Cast <Match>()
.Select(IvyPackageFileData.CreateFromRegexMatch).ToList();
var packageDir = Path.GetDirectoryName(ivyFile);
packages.Add(packageDir, artifacts);
}
catch (Exception ex)
{
Console.WriteLine("Error reading extensions from ivy.xml file at {0}: {1}", ivyFile, ex);
}
}
try
{
foreach (var packageInfo in packages)
{
var files = packageInfo.Value;
foreach (var packageInfoFile in files)
{
string fullPath = Paths.NormalizePath(Path.Combine(packageInfo.Key, packageInfoFile.filename));
if (!File.Exists(fullPath))
{
Debug.LogWarningFormat(
"Missing assembly \t{0} listed in ivy file {1}. Extension support may be incomplete.", fullPath,
packageInfo.Key);
}
if (!packageInfoFile.IsDll)
{
continue;
}
if (!string.IsNullOrEmpty(packageInfoFile.guid))
{
InternalEditorUtility.RegisterExtensionDll(fullPath.Replace('\\', '/'),
packageInfoFile.guid);
}
else
{
InternalEditorUtility.RegisterPrecompiledAssembly(fullPath, fullPath);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error scanning for extensions. {0}", ex);
}
}
private static void Run(CommandLineApplication cmd, ILogger log)
{
cmd.Description = "Remove package dependencies";
// Filters
var idFilter = cmd.Option(Constants.IdFilterTemplate, Constants.IdFilterDesc, CommandOptionType.SingleValue);
var versionFilter = cmd.Option(Constants.VersionFilterTemplate, Constants.VersionFilterDesc, CommandOptionType.SingleValue);
var excludeSymbolsFilter = cmd.Option(Constants.ExcludeSymbolsTemplate, Constants.ExcludeSymbolsDesc, CommandOptionType.NoValue);
var highestVersionFilter = cmd.Option(Constants.HighestVersionFilterTemplate, Constants.HighestVersionFilterDesc, CommandOptionType.NoValue);
// Command options
var frameworkOption = cmd.Option(Constants.FrameworkOptionTemplate, Constants.FrameworkOptionDesc, CommandOptionType.MultipleValue);
var dependencyIdOption = cmd.Option(Constants.DependencyIdTemplate, Constants.DependencyIdDesc, CommandOptionType.SingleValue);
var argRoot = cmd.Argument(
"[root]",
Constants.MultiplePackagesRootDesc,
true);
cmd.HelpOption(Constants.HelpOption);
cmd.OnExecute(() =>
{
try
{
var inputs = argRoot.Values;
if (inputs.Count < 1)
{
inputs.Add(Directory.GetCurrentDirectory());
}
var dependencyId = dependencyIdOption.HasValue() ? dependencyIdOption.Value() : null;
var type = dependencyIdOption.HasValue() ? DependenciesUtil.EditType.Remove : DependenciesUtil.EditType.Clear;
var editForFrameworks = new HashSet <NuGetFramework>();
if (frameworkOption.HasValue())
{
editForFrameworks.UnionWith(frameworkOption.Values.Select(NuGetFramework.Parse));
if (type == DependenciesUtil.EditType.Clear)
{
log.LogInformation($"removing all dependencies from {string.Join(", ", editForFrameworks.Select(e => e.GetShortFolderName()))}");
}
else
{
log.LogInformation($"removing dependency {dependencyId} from {string.Join(", ", editForFrameworks.Select(e => e.GetShortFolderName()))}");
}
}
else
{
if (type == DependenciesUtil.EditType.Clear)
{
log.LogInformation($"removing all dependencies");
}
else
{
log.LogInformation($"removing dependency {dependencyId} from all frameworks");
}
}
var packages = Util.GetPackagesWithFilter(idFilter, versionFilter, excludeSymbolsFilter, highestVersionFilter, inputs.ToArray());
foreach (var package in packages)
{
log.LogMinimal($"processing {package}");
var nuspecXml = Util.GetNuspec(package);
DependenciesUtil.Process(nuspecXml, type, editForFrameworks, dependencyId, null, null, null, false, false, log);
Util.ReplaceNuspec(package, nuspecXml, log);
}
return(0);
}
catch (Exception ex)
{
log.LogError(ex.Message);
log.LogError(ex.ToString());
}
return(1);
});
}
private static IEnumerable <ComposedPartDiagnostic> FindLoops(IEnumerable <ComposedPart> parts)
{
Requires.NotNull(parts, nameof(parts));
var partByPartDefinition = parts.ToDictionary(p => p.Definition);
var partByPartType = parts.ToDictionary(p => p.Definition.TypeRef);
var partsAndDirectImports = new Dictionary <ComposedPart, IReadOnlyList <KeyValuePair <ImportDefinitionBinding, ComposedPart> > >();
foreach (var part in parts)
{
var directlyImportedParts = (from importAndExports in part.SatisfyingExports
from export in importAndExports.Value
let exportingPart = partByPartDefinition[export.PartDefinition]
select new KeyValuePair <ImportDefinitionBinding, ComposedPart>(importAndExports.Key, exportingPart)).ToList();
partsAndDirectImports.Add(part, directlyImportedParts);
}
Func <Func <KeyValuePair <ImportDefinitionBinding, ComposedPart>, bool>, Func <ComposedPart, IEnumerable <ComposedPart> > > getDirectLinksWithFilter =
filter => (part => partsAndDirectImports[part].Where(filter).Select(ip => ip.Value));
var visited = new HashSet <ComposedPart>();
// Find any loops of exclusively non-shared parts.
var nonSharedPartsInLoops = new HashSet <ComposedPart>();
foreach (var part in partsAndDirectImports.Keys)
{
if (nonSharedPartsInLoops.Contains(part))
{
// Don't check and report parts already detected to be involved in a loop.
continue;
}
visited.Clear();
var path = PathExistsBetween(part, part, getDirectLinksWithFilter(ip => !ip.Key.IsExportFactory && (!ip.Value.Definition.IsShared || PartCreationPolicyConstraint.IsNonSharedInstanceRequired(ip.Key.ImportDefinition))), visited);
if (!path.IsEmpty)
{
path = path.Push(part);
nonSharedPartsInLoops.UnionWith(path);
yield return(new ComposedPartDiagnostic(path, Strings.LoopBetweenNonSharedParts));
}
}
// Find loops even with shared parts where an importing constructor is involved.
Func <KeyValuePair <ImportDefinitionBinding, ComposedPart>, bool> importingConstructorFilter = ip => !ip.Key.IsExportFactory && !ip.Key.IsLazy;
foreach (var partAndImports in partsAndDirectImports)
{
var importingPart = partAndImports.Key;
foreach (var import in partAndImports.Value)
{
var importDefinitionBinding = import.Key;
var satisfyingPart = import.Value;
if (importDefinitionBinding.ImportingParameterRef != null && importingConstructorFilter(import))
{
visited.Clear();
var path = PathExistsBetween(satisfyingPart, importingPart, getDirectLinksWithFilter(importingConstructorFilter), visited);
if (!path.IsEmpty)
{
path = path.Push(satisfyingPart).Push(partByPartType[importDefinitionBinding.ComposablePartTypeRef]);
yield return(new ComposedPartDiagnostic(path, Strings.LoopInvolvingImportingCtorArgumentAndAllNonLazyImports));
}
}
}
}
}
private static void PushSameDependABToABUnit(IAssetDataQuerier varQuerier, List <string> varRepeatAssets,
Dictionary <string, List <string> > varAssetBeDep, Dictionary <string, List <string> > varABBeDep, Dictionary <string, List <string> > varABDepABs)
{
var tempHashSetHelper = new HashSet <string>();
for (int iR = 0; iR < varRepeatAssets.Count; ++iR)
{
var tempAssetPath = varRepeatAssets[iR];
var tempAssetBeDeps = varAssetBeDep[tempAssetPath];
if (tempAssetBeDeps.Count < 2)
{
UDebug.LogErrorFormat("Repeat analysis error.[{0}]", tempAssetPath);
iR++;
continue;
}
tempHashSetHelper.Clear();
for (int iBD = 0; iBD < tempAssetBeDeps.Count; ++iBD)
{
var tempABName = tempAssetBeDeps[iBD];
tempHashSetHelper.UnionWith(varABDepABs[tempABName]);
tempHashSetHelper.Add(tempABName);
}
var tempAllABDeps = tempHashSetHelper.OrderBy(a => a).ToList();
for (int iAD = tempAllABDeps.Count - 1; iAD >= 0; --iAD)
{
var tempABName = tempAllABDeps[iAD];
if (!varABBeDep.TryGetValue(tempABName, out var tempBeDeps))
{
continue;
}
if (tempAssetBeDeps.Count != tempBeDeps.Count)
{
continue;
}
bool tempSame = true;
for (int iBD = 0; iBD < tempAssetBeDeps.Count; ++iBD)
{
if (tempAssetBeDeps[iBD] == tempBeDeps[iBD])
{
continue;
}
tempSame = false;
break;
}
if (!tempSame)
{
continue;
}
varQuerier.SetAssetBundleName(tempAssetPath, tempABName);
varRepeatAssets.RemoveAt(iR);
iR++;
break;
}
}
}
internal void PrefetchCompositesAssociationRelationTable(HashSet <Reference> roles, IAssociationType associationType, HashSet <long> nestedObjectIds, HashSet <long> leafs)
{
var references = nestedObjectIds == null?this.FilterForPrefetchAssociations(roles, associationType) : this.FilterForPrefetchCompositeAssociations(roles, associationType, nestedObjectIds);
if (references.Count == 0)
{
return;
}
Command command;
if (!this.PrefetchCompositeAssociationByAssociationType.TryGetValue(associationType, out command))
{
var roleType = associationType.RoleType;
var sql = this.Database.Mapping.ProcedureNameForPrefetchAssociationByRelationType[roleType.RelationType];
command = this.Session.Connection.CreateCommand();
command.CommandText = sql;
command.CommandType = CommandType.StoredProcedure;
command.AddObjectTableParameter(roles);
this.prefetchCompositeAssociationByAssociationType[associationType] = command;
}
else
{
command.Parameters[Mapping.ParamNameForTableType].Value = this.Database.CreateObjectTable(roles);
}
var prefetchedAssociations = new HashSet <long>();
var prefetchedAssociationByRole = new Dictionary <Reference, List <long> >();
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
var roleId = reader.GetInt64(1);
var roleReference = this.Session.State.ReferenceByObjectId[roleId];
List <long> associations;
if (!prefetchedAssociationByRole.TryGetValue(roleReference, out associations))
{
associations = new List <long>();
prefetchedAssociationByRole.Add(roleReference, associations);
}
var associationId = reader.GetInt64(0);
associations.Add(associationId);
prefetchedAssociations.Add(associationId);
}
}
foreach (var associationId in prefetchedAssociations)
{
if (associationType.ObjectType.ExistExclusiveClass)
{
this.Session.State.GetOrCreateReferenceForExistingObject(associationType.ObjectType.ExclusiveClass, associationId, this.Session);
}
else
{
this.Session.State.GetOrCreateReferenceForExistingObject(associationId, this.Session);
}
}
var associationsByRole = this.Session.State.GetAssociationsByRole(associationType);
foreach (var role in roles)
{
if (!associationsByRole.ContainsKey(role))
{
List <long> associationIds;
if (!prefetchedAssociationByRole.TryGetValue(role, out associationIds))
{
associationsByRole[role] = EmptyObjectIds;
}
else
{
associationsByRole[role] = associationIds.ToArray();
nestedObjectIds?.UnionWith(associationIds);
if (nestedObjectIds == null)
{
leafs.UnionWith(associationIds);
}
}
this.Session.FlushConditionally(role.ObjectId, associationType);
}
}
}
public Transaction MakeTransaction(List <TransactionAttribute> attributes, IEnumerable <TransferOutput> outputs, UInt160 from = null, UInt160 change_address = null, Fixed8 fee = default(Fixed8))
{
var cOutputs = outputs.Where(p => !p.IsGlobalAsset).GroupBy(p => new
{
AssetId = (UInt160)p.AssetId,
Account = p.ScriptHash
}, (k, g) => new
{
k.AssetId,
Value = g.Aggregate(BigInteger.Zero, (x, y) => x + y.Value.Value),
k.Account
}).ToArray();
Transaction tx;
if (attributes == null)
{
attributes = new List <TransactionAttribute>();
}
if (cOutputs.Length == 0)
{
tx = new ContractTransaction();
}
else
{
UInt160[] accounts = from == null?GetAccounts().Where(p => !p.Lock && !p.WatchOnly).Select(p => p.ScriptHash).ToArray() : new[] { from };
HashSet <UInt160> sAttributes = new HashSet <UInt160>();
using (ScriptBuilder sb = new ScriptBuilder())
{
foreach (var output in cOutputs)
{
var balances = new List <(UInt160 Account, BigInteger Value)>();
foreach (UInt160 account in accounts)
{
byte[] script;
using (ScriptBuilder sb2 = new ScriptBuilder())
{
sb2.EmitAppCall(output.AssetId, "balanceOf", account);
script = sb2.ToArray();
}
ApplicationEngine engine = ApplicationEngine.Run(script);
if (engine.State.HasFlag(VMState.FAULT))
{
return(null);
}
balances.Add((account, engine.ResultStack.Pop().GetBigInteger()));
}
BigInteger sum = balances.Aggregate(BigInteger.Zero, (x, y) => x + y.Value);
if (sum < output.Value)
{
return(null);
}
if (sum != output.Value)
{
balances = balances.OrderByDescending(p => p.Value).ToList();
BigInteger amount = output.Value;
int i = 0;
while (balances[i].Value <= amount)
{
amount -= balances[i++].Value;
}
if (amount == BigInteger.Zero)
{
balances = balances.Take(i).ToList();
}
else
{
balances = balances.Take(i).Concat(new[] { balances.Last(p => p.Value >= amount) }).ToList();
}
sum = balances.Aggregate(BigInteger.Zero, (x, y) => x + y.Value);
}
sAttributes.UnionWith(balances.Select(p => p.Account));
for (int i = 0; i < balances.Count; i++)
{
BigInteger value = balances[i].Value;
if (i == 0)
{
BigInteger change = sum - output.Value;
if (change > 0)
{
value -= change;
}
}
sb.EmitAppCall(output.AssetId, "transfer", balances[i].Account, output.Account, value);
sb.Emit(OpCode.THROWIFNOT);
}
}
byte[] nonce = new byte[8];
rand.NextBytes(nonce);
sb.Emit(OpCode.RET, nonce);
tx = new InvocationTransaction
{
Version = 1,
Script = sb.ToArray()
};
}
attributes.AddRange(sAttributes.Select(p => new TransactionAttribute
{
Usage = TransactionAttributeUsage.Script,
Data = p.ToArray()
}));
}
tx.Attributes = attributes.ToArray();
tx.Inputs = new CoinReference[0];
tx.Outputs = outputs.Where(p => p.IsGlobalAsset).Select(p => p.ToTxOutput()).ToArray();
tx.Witnesses = new Witness[0];
if (tx is InvocationTransaction itx)
{
ApplicationEngine engine = ApplicationEngine.Run(itx.Script, itx);
if (engine.State.HasFlag(VMState.FAULT))
{
return(null);
}
tx = new InvocationTransaction
{
Version = itx.Version,
Script = itx.Script,
Gas = InvocationTransaction.GetGas(engine.GasConsumed),
Attributes = itx.Attributes,
Inputs = itx.Inputs,
Outputs = itx.Outputs
};
}
tx = MakeTransaction(tx, from, change_address, fee);
return(tx);
}
public void Initialize(bool remote, string[] containRevisons)
{
lbChanges.Text = "";
LocalBranch.Checked = !remote;
Remotebranch.Checked = remote;
_containRevisons = containRevisons;
Branches.Items.Clear();
Branches.Items.AddRange(_containRevisons != null
? GetContainsRevisionBranches()
: LocalBranch.Checked
? GetLocalBranches()
: GetRemoteBranches());
if (_containRevisons != null && Branches.Items.Count == 1)
{
Branches.SelectedIndex = 0;
}
else
{
Branches.Text = null;
}
string[] GetLocalBranches()
{
if (_localBranches == null)
{
_localBranches = Module.GetRefs(false).Select(b => b.Name).ToArray();
}
return(_localBranches);
}
string[] GetRemoteBranches()
{
if (_remoteBranches == null)
{
_remoteBranches = Module.GetRefs(true, true).Where(h => h.IsRemote && !h.IsTag).Select(b => b.Name).ToArray();
}
return(_remoteBranches);
}
string[] GetContainsRevisionBranches()
{
var result = new HashSet <string>();
if (_containRevisons.Length > 0)
{
var branches = Module.GetAllBranchesWhichContainGivenCommit(_containRevisons[0], LocalBranch.Checked,
!LocalBranch.Checked)
.Where(a => !DetachedHeadParser.IsDetachedHead(a) &&
!a.EndsWith("/HEAD"));
result.UnionWith(branches);
}
for (int index = 1; index < _containRevisons.Length; index++)
{
var containRevison = _containRevisons[index];
var branches =
Module.GetAllBranchesWhichContainGivenCommit(containRevison, LocalBranch.Checked,
!LocalBranch.Checked)
.Where(a => !DetachedHeadParser.IsDetachedHead(a) &&
!a.EndsWith("/HEAD"));
result.IntersectWith(branches);
}
return(result.ToArray());
}
}
private static void BuildDictionaries(ParsedEvtcLog log, Dictionary <long, Buff> usedBuffs, HashSet <DamageModifier> usedDamageMods, LogDataDto logData, HashSet <string> allDamageMods, List <DamageModifier> commonDamageModifiers, List <DamageModifier> itemDamageModifiers)
{
foreach (AbstractSingleActor actor in log.Friendlies)
{
allDamageMods.UnionWith(actor.GetPresentDamageModifier(log));
}
if (log.DamageModifiers.DamageModifiersPerSource.TryGetValue(Source.Common, out IReadOnlyList <DamageModifier> list))
{
foreach (DamageModifier dMod in list)
{
if (allDamageMods.Contains(dMod.Name))
{
commonDamageModifiers.Add(dMod);
logData.DmgModifiersCommon.Add(dMod.ID);
usedDamageMods.Add(dMod);
}
}
}
if (log.DamageModifiers.DamageModifiersPerSource.TryGetValue(Source.FightSpecific, out list))
{
foreach (DamageModifier dMod in list)
{
if (allDamageMods.Contains(dMod.Name))
{
commonDamageModifiers.Add(dMod);
logData.DmgModifiersCommon.Add(dMod.ID);
usedDamageMods.Add(dMod);
}
}
}
if (log.DamageModifiers.DamageModifiersPerSource.TryGetValue(Source.Item, out list))
{
foreach (DamageModifier dMod in list)
{
if (allDamageMods.Contains(dMod.Name))
{
itemDamageModifiers.Add(dMod);
logData.DmgModifiersItem.Add(dMod.ID);
usedDamageMods.Add(dMod);
}
}
}
if (log.DamageModifiers.DamageModifiersPerSource.TryGetValue(Source.Gear, out list))
{
foreach (DamageModifier dMod in list)
{
if (allDamageMods.Contains(dMod.Name))
{
itemDamageModifiers.Add(dMod);
logData.DmgModifiersItem.Add(dMod.ID);
usedDamageMods.Add(dMod);
}
}
}
StatisticsHelper statistics = log.StatisticsHelper;
foreach (Buff boon in statistics.PresentBoons)
{
logData.Boons.Add(boon.ID);
usedBuffs[boon.ID] = boon;
}
foreach (Buff condition in statistics.PresentConditions)
{
logData.Conditions.Add(condition.ID);
usedBuffs[condition.ID] = condition;
}
foreach (Buff offBuff in statistics.PresentOffbuffs)
{
logData.OffBuffs.Add(offBuff.ID);
usedBuffs[offBuff.ID] = offBuff;
}
foreach (Buff supBuff in statistics.PresentSupbuffs)
{
logData.SupBuffs.Add(supBuff.ID);
usedBuffs[supBuff.ID] = supBuff;
}
foreach (Buff defBuff in statistics.PresentDefbuffs)
{
logData.DefBuffs.Add(defBuff.ID);
usedBuffs[defBuff.ID] = defBuff;
}
foreach (Buff debuff in statistics.PresentDebuffs)
{
logData.Debuffs.Add(debuff.ID);
usedBuffs[debuff.ID] = debuff;
}
foreach (Buff gearBuff in statistics.PresentGearbuffs)
{
logData.GearBuffs.Add(gearBuff.ID);
usedBuffs[gearBuff.ID] = gearBuff;
}
foreach (Buff fractalInstab in statistics.PresentFractalInstabilities)
{
logData.FractalInstabilities.Add(fractalInstab.ID);
usedBuffs[fractalInstab.ID] = fractalInstab;
}
}
private void SingleStepReduce(IndexToWorkOn index, string[] keysToReduce, AbstractViewGenerator viewGenerator,
List <object> itemsToDelete)
{
var needToMoveToSingleStepQueue = new ConcurrentQueue <HashSet <string> >();
Log.Debug(() => string.Format("Executing single step reducing for {0} keys [{1}]", keysToReduce.Length, string.Join(", ", keysToReduce)));
var batchTimeWatcher = Stopwatch.StartNew();
var count = 0;
var size = 0;
var state = new ConcurrentQueue <Tuple <HashSet <string>, List <MappedResultInfo> > >();
BackgroundTaskExecuter.Instance.ExecuteAllBuffered(context, keysToReduce, enumerator =>
{
var localNeedToMoveToSingleStep = new HashSet <string>();
needToMoveToSingleStepQueue.Enqueue(localNeedToMoveToSingleStep);
var localKeys = new HashSet <string>();
while (enumerator.MoveNext())
{
localKeys.Add(enumerator.Current);
}
transactionalStorage.Batch(actions =>
{
var getItemsToReduceParams = new GetItemsToReduceParams(index: index.IndexName, reduceKeys: localKeys, level: 0,
loadData: false,
itemsToDelete: itemsToDelete)
{
Take = int.MaxValue // just get all, we do the rate limit when we load the number of keys to reduce, anyway
};
var scheduledItems = actions.MapReduce.GetItemsToReduce(getItemsToReduceParams).ToList();
if (scheduledItems.Count == 0)
{
if (Log.IsWarnEnabled)
{
Log.Warn("Found single reduce items ({0}) that didn't have any items to reduce. Deleting level 1 & level 2 items for those keys. (If you can reproduce this, please contact [email protected])",
string.Join(", ", keysToReduce));
}
// Here we have an interesting issue. We have scheduled reductions, because GetReduceTypesPerKeys() returned them
// and at the same time, we don't have any at level 0. That probably means that we have them at level 1 or 2.
// They shouldn't be here, and indeed, we remove them just a little down from here in this function.
// That said, they might bave smuggled in between versions, or something happened to cause them to be here.
// In order to avoid that, we forcibly delete those extra items from the scheduled reductions, and move on
foreach (var reduceKey in keysToReduce)
{
actions.MapReduce.DeleteScheduledReduction(index.IndexName, 1, reduceKey);
actions.MapReduce.DeleteScheduledReduction(index.IndexName, 2, reduceKey);
}
}
foreach (var reduceKey in localKeys)
{
var lastPerformedReduceType = actions.MapReduce.GetLastPerformedReduceType(index.IndexName, reduceKey);
if (lastPerformedReduceType != ReduceType.SingleStep)
{
localNeedToMoveToSingleStep.Add(reduceKey);
}
if (lastPerformedReduceType != ReduceType.MultiStep)
{
continue;
}
Log.Debug("Key {0} was moved from multi step to single step reduce, removing existing reduce results records",
reduceKey);
// now we are in single step but previously multi step reduce was performed for the given key
var mappedBuckets = actions.MapReduce.GetMappedBuckets(index.IndexName, reduceKey).ToList();
// add scheduled items too to be sure we will delete reduce results of already deleted documents
mappedBuckets.AddRange(scheduledItems.Select(x => x.Bucket));
foreach (var mappedBucket in mappedBuckets.Distinct())
{
actions.MapReduce.RemoveReduceResults(index.IndexName, 1, reduceKey, mappedBucket);
actions.MapReduce.RemoveReduceResults(index.IndexName, 2, reduceKey, mappedBucket / 1024);
}
}
var mappedResults = actions.MapReduce.GetMappedResults(
index.IndexName,
localKeys,
loadData: true
).ToList();
Interlocked.Add(ref count, mappedResults.Count);
Interlocked.Add(ref size, mappedResults.Sum(x => x.Size));
mappedResults.ApplyIfNotNull(x => x.Bucket = 0);
state.Enqueue(Tuple.Create(localKeys, mappedResults));
});
});
var reduceKeys = new HashSet <string>(state.SelectMany(x => x.Item1));
var results = state.SelectMany(x => x.Item2)
.Where(x => x.Data != null)
.GroupBy(x => x.Bucket, x => JsonToExpando.Convert(x.Data))
.ToArray();
context.ReducedPerSecIncreaseBy(results.Length);
context.TransactionalStorage.Batch(actions =>
context.IndexStorage.Reduce(index.IndexName, viewGenerator, results, 2, context, actions, reduceKeys, state.Sum(x => x.Item2.Count))
);
autoTuner.AutoThrottleBatchSize(count, size, batchTimeWatcher.Elapsed);
var needToMoveToSingleStep = new HashSet <string>();
HashSet <string> set;
while (needToMoveToSingleStepQueue.TryDequeue(out set))
{
needToMoveToSingleStep.UnionWith(set);
}
foreach (var reduceKey in needToMoveToSingleStep)
{
string localReduceKey = reduceKey;
transactionalStorage.Batch(actions =>
actions.MapReduce.UpdatePerformedReduceType(index.IndexName, localReduceKey, ReduceType.SingleStep));
}
}
public static string GenerateDomainCheckMethodContent(IRelationDomain sourceDomain, ISet <IVariable> variablesBindedSoFar, DomainVariablesBindingsResult analysis, List <IObjectTemplateExp> remaining = null, StringBuilder stringBuilder = null, ISet <IPropertyTemplateItem> postPonedPropertiesToCheck = null)
{
if (remaining == null)
{
remaining = QvtModelExplorer.FindAllObjectTemplates(sourceDomain).Where(o => !o.IsAntiTemplate()).ToList();
}
if (stringBuilder == null)
{
stringBuilder = new StringBuilder();
}
if (postPonedPropertiesToCheck == null)
{
postPonedPropertiesToCheck = new HashSet <IPropertyTemplateItem>();
}
if (remaining.Count > 0)
{
IObjectTemplateExp current = remaining[0];
remaining.RemoveAt(0);
string currentVariableName = current.BindsTo.Name;
variablesBindedSoFar.Add(current.BindsTo);
// Generate conditional for the object template
stringBuilder.AppendLine("if (" + currentVariableName + " != null) {");
// Generate bindings for each non-many free variables
ISet <IPropertyTemplateItem> managedProps = new HashSet <IPropertyTemplateItem>();
foreach (IPropertyTemplateItem nonManyProp in current.Part.Where(prop =>
(prop.Value is ObjectTemplateExp || prop.Value is VariableExp) &&
!prop.ReferredProperty.isMany()))
{
IVariable bindedVariable = QvtModelExplorer.FindBindedVariables(nonManyProp).Single();
if (bindedVariable != null && !variablesBindedSoFar.Contains(bindedVariable))
{
managedProps.Add(nonManyProp);
stringBuilder.AppendLine(GenerateBindingFreeNonMany(nonManyProp, bindedVariable));
variablesBindedSoFar.Add(bindedVariable);
}
}
// We compute the checks that we can do right now, and the ones that must be post poned because their variables are not binded yet
// For now we only do checks on single value properties, the many valued one are simply exhaustively explored/binded later
IEnumerable <IPropertyTemplateItem> candidatesInit = current.Part.Where(prop => !prop.ReferredProperty.isMany() && (prop.Value is CSharpOpaqueExpression || prop.Value is IVariableExp));
ISet <IPropertyTemplateItem> candidates = new HashSet <IPropertyTemplateItem>();
candidates.UnionWith(candidatesInit);
candidates.UnionWith(postPonedPropertiesToCheck);
candidates.ExceptWith(managedProps);
ISet <IPropertyTemplateItem> propsToCheck = new HashSet <IPropertyTemplateItem>();
foreach (IPropertyTemplateItem candidate in candidates)
{
if (!variablesBindedSoFar.IsSupersetOf(QvtModelExplorer.FindBindedVariables(candidate)))
{
propsToCheck.Remove(candidate);
postPonedPropertiesToCheck.Add(candidate);
}
else
{
propsToCheck.Add(candidate);
postPonedPropertiesToCheck.Remove(candidate);
}
}
// We generate the checks for all the ones that can be made now
if (propsToCheck.Count > 0)
{
IEnumerable <string> conditions = propsToCheck.Select(u => GenerateConditionnalProperty(u, true));
string condition = string.Join(" && ", conditions);
stringBuilder.AppendLine("if (" + condition + ") {");
}
// We make a recursion for each object template not managed yet
// - If the ref is many, then we make the binding first using a loop
// - If the ref is not many, the binding was done before when managing non-many
List <IPropertyTemplateItem> objectTemplatesManyRemaining = current.Part.Where(p => p.Value is ObjectTemplateExp && p.ReferredProperty.isMany() && remaining.Contains(p.Value)).ToList();
foreach (IPropertyTemplateItem propWithTemplate in objectTemplatesManyRemaining)
{
// Generate start for each, which binds the variable associated with the object template
ObjectTemplateExp objectTemplate = (ObjectTemplateExp)propWithTemplate.Value;
stringBuilder.AppendLine("foreach (" + objectTemplate.BindsTo.Type.GetRealTypeName() + " " + objectTemplate.BindsTo.Name + " in " + currentVariableName + "." + propWithTemplate.ReferredProperty.Name + ".OfType<" + propWithTemplate.ReferredProperty.Type.GetRealTypeName() + ">()) {");
variablesBindedSoFar.Add(objectTemplate.BindsTo);
}
GenerateDomainCheckMethodContent(sourceDomain, variablesBindedSoFar, analysis, remaining, stringBuilder, postPonedPropertiesToCheck);
foreach (IPropertyTemplateItem _ in objectTemplatesManyRemaining)
{
// Generate end for each
stringBuilder.AppendLine("}");
}
// Generate end if checks all c# expressions
if (propsToCheck.Count > 0)
{
stringBuilder.Append("}");
}
// End conditional on the object template
stringBuilder.AppendLine("}");
}
// We stop the recursion if there are no more object templates to manage
else
{
string matchClassName = QvtCodeGeneratorStrings.MatchDomainClassName(sourceDomain);
// Now we can finally create the Match object
stringBuilder.AppendLine(matchClassName + " match = new " + matchClassName + "() {");
foreach (IVariable variable in analysis.VariablesItCanBind)
{
stringBuilder.AppendLine(variable.Name + " = " + variable.Name + ",");
}
stringBuilder.AppendLine("};");
stringBuilder.AppendLine("result.Add(match);");
}
return(stringBuilder.ToString());
}
public async Task <IActionResult> PostInputsAsync([FromBody] InputsRequest request)
{
// Validate request.
if (!ModelState.IsValid ||
request is null ||
string.IsNullOrWhiteSpace(request.BlindedOutputScriptHex) ||
string.IsNullOrWhiteSpace(request.ChangeOutputAddress) ||
request.Inputs is null ||
!request.Inputs.Any() ||
request.Inputs.Any(x => x.Input == default(TxoRef) ||
x.Input.TransactionId is null ||
string.IsNullOrWhiteSpace(x.Proof)))
{
return(BadRequest("Invalid request."));
}
if (request.Inputs.Count() > 7)
{
return(BadRequest("Maximum 7 inputs can be registered."));
}
using (await InputsLock.LockAsync())
{
CcjRound round = Coordinator.GetCurrentInputRegisterableRound();
// Do more checks.
try
{
if (round.ContainsBlindedOutputScriptHex(request.BlindedOutputScriptHex, out _))
{
return(BadRequest("Blinded output has already been registered."));
}
BitcoinAddress changeOutputAddress;
try
{
changeOutputAddress = BitcoinAddress.Create(request.ChangeOutputAddress, Network);
}
catch (FormatException ex)
{
return(BadRequest($"Invalid ChangeOutputAddress. Details: {ex.Message}"));
}
var inputs = new HashSet <(OutPoint OutPoint, TxOut Output)>();
var alicesToRemove = new HashSet <Guid>();
foreach (InputProofModel inputProof in request.Inputs)
{
if (inputs.Any(x => x.OutPoint == inputProof.Input))
{
return(BadRequest("Cannot register an input twice."));
}
if (round.ContainsInput(inputProof.Input.ToOutPoint(), out List <Alice> tr))
{
alicesToRemove.UnionWith(tr.Select(x => x.UniqueId)); // Input is already registered by this alice, remove it later if all the checks are completed fine.
}
if (Coordinator.AnyRunningRoundContainsInput(inputProof.Input.ToOutPoint(), out List <Alice> tnr))
{
if (tr.Union(tnr).Count() > tr.Count())
{
return(BadRequest("Input is already registered in another round."));
}
}
OutPoint outpoint = inputProof.Input.ToOutPoint();
if (Coordinator.UtxoReferee.BannedUtxos.TryGetValue(outpoint, out (int severity, DateTimeOffset timeOfBan)bannedElem))
{
int maxBan = (int)TimeSpan.FromHours((long)Global.RoundConfig.DosDurationHours).TotalMinutes;
int banLeft = maxBan - (int)(DateTimeOffset.UtcNow - bannedElem.timeOfBan).TotalMinutes;
if (banLeft > 0)
{
return(BadRequest($"Input is banned from participation for {banLeft} minutes: {inputProof.Input.Index}:{inputProof.Input.TransactionId}."));
}
await Coordinator.UtxoReferee.UnbanAsync(outpoint);
}
GetTxOutResponse getTxOutResponse = await RpcClient.GetTxOutAsync(inputProof.Input.TransactionId, (int)inputProof.Input.Index, includeMempool : true);
// Check if inputs are unspent.
if (getTxOutResponse is null)
{
return(BadRequest($"Provided input is not unspent: {inputProof.Input.Index}:{inputProof.Input.TransactionId}"));
}
// Check if unconfirmed.
if (getTxOutResponse.Confirmations <= 0)
{
// If it spends a CJ then it may be acceptable to register.
if (!Coordinator.ContainsCoinJoin(inputProof.Input.TransactionId))
{
return(BadRequest("Provided input is neither confirmed, nor is from an unconfirmed coinjoin."));
}
// After 24 unconfirmed cj in the mempool dont't let unconfirmed coinjoin to be registered.
if (await Coordinator.IsUnconfirmedCoinJoinLimitReachedAsync())
{
return(BadRequest("Provided input is from an unconfirmed coinjoin, but the maximum number of unconfirmed coinjoins is reached."));
}
}
// Check if immature.
if (getTxOutResponse.Confirmations <= 100)
{
if (getTxOutResponse.IsCoinBase)
{
return(BadRequest("Provided input is immature."));
}
}
// Check if inputs are native segwit.
if (getTxOutResponse.ScriptPubKeyType != "witness_v0_keyhash")
{
return(BadRequest("Provided input must be witness_v0_keyhash."));
}
TxOut txout = getTxOutResponse.TxOut;
var address = (BitcoinWitPubKeyAddress)txout.ScriptPubKey.GetDestinationAddress(Network);
// Check if proofs are valid.
bool validProof;
try
{
validProof = address.VerifyMessage(request.BlindedOutputScriptHex, inputProof.Proof);
}
catch (FormatException ex)
{
return(BadRequest($"Provided proof is invalid: {ex.Message}"));
}
if (!validProof)
{
return(BadRequest("Provided proof is invalid."));
}
inputs.Add((inputProof.Input.ToOutPoint(), txout));
}
// Check if inputs have enough coins.
Money inputSum = inputs.Select(x => x.Output.Value).Sum();
Money networkFeeToPay = (inputs.Count() * round.FeePerInputs) + (2 * round.FeePerOutputs);
Money changeAmount = inputSum - (round.Denomination + networkFeeToPay);
if (changeAmount < Money.Zero)
{
return(BadRequest($"Not enough inputs are provided. Fee to pay: {networkFeeToPay.ToString(false, true)} BTC. Round denomination: {round.Denomination.ToString(false, true)} BTC. Only provided: {inputSum.ToString(false, true)} BTC."));
}
// Make sure Alice checks work.
var alice = new Alice(inputs, networkFeeToPay, changeOutputAddress, request.BlindedOutputScriptHex);
foreach (Guid aliceToRemove in alicesToRemove)
{
round.RemoveAlicesBy(aliceToRemove);
}
round.AddAlice(alice);
// All checks are good. Sign.
byte[] blindedData;
try
{
blindedData = ByteHelpers.FromHex(request.BlindedOutputScriptHex);
}
catch
{
return(BadRequest("Invalid blinded output hex."));
}
byte[] signature = RsaKey.SignBlindedData(blindedData);
// Check if phase changed since.
if (round.Status != CcjRoundStatus.Running || round.Phase != CcjRoundPhase.InputRegistration)
{
return(base.StatusCode(StatusCodes.Status503ServiceUnavailable, "The state of the round changed while handling the request. Try again."));
}
// Progress round if needed.
if (round.CountAlices() >= round.AnonymitySet)
{
await round.RemoveAlicesIfInputsSpentAsync();
if (round.CountAlices() >= round.AnonymitySet)
{
await round.ExecuteNextPhaseAsync(CcjRoundPhase.ConnectionConfirmation);
}
}
var resp = new InputsResponse
{
UniqueId = alice.UniqueId,
BlindedOutputSignature = signature,
RoundId = round.RoundId
};
return(Ok(resp));
}
catch (Exception ex)
{
Logger.LogDebug <ChaumianCoinJoinController>(ex);
return(BadRequest(ex.Message));
}
}
}
public void Draw()
{
if (World.WorldActor.Disposed)
{
return;
}
if (debugVis.Value != null && lastDepthPreviewEnabled != debugVis.Value.DepthBuffer)
{
lastDepthPreviewEnabled = debugVis.Value.DepthBuffer;
Game.Renderer.WorldSpriteRenderer.SetDepthPreviewEnabled(lastDepthPreviewEnabled);
}
RefreshPalette();
onScreenActors.UnionWith(World.ScreenMap.RenderableActorsInBox(Viewport.TopLeft, Viewport.BottomRight));
var renderables = GenerateRenderables();
var bounds = Viewport.GetScissorBounds(World.Type != WorldType.Editor);
Game.Renderer.EnableScissor(bounds);
if (enableDepthBuffer)
{
Game.Renderer.Context.EnableDepthBuffer();
}
if (terrainRenderer != null)
{
terrainRenderer.RenderTerrain(this, Viewport);
}
Game.Renderer.Flush();
for (var i = 0; i < renderables.Count; i++)
{
renderables[i].Render(this); //пишет в WorldSpriteRenderer инфу о каждом renderables
}
Game.Renderer.Flush();
if (enableDepthBuffer)
{
Game.Renderer.ClearDepthBuffer();
}
foreach (var a in World.ActorsWithTrait <IRenderAboveWorld>())
{
if (a.Actor.IsInWorld && !a.Actor.Disposed)
{
a.Trait.RenderAboveWorld(a.Actor, this);
}
}
var renderShroud = World.RenderPlayer != null ? World.RenderPlayer.Shroud : null;
if (enableDepthBuffer)
{
Game.Renderer.ClearDepthBuffer();
}
foreach (var a in World.ActorsWithTrait <IRenderShroud>())
{
a.Trait.RenderShroud(renderShroud, this);
}
if (enableDepthBuffer)
{
Game.Renderer.Context.DisableDepthBuffer();
}
Game.Renderer.DisableScissor();
var finalOverlayRenderables = GenerateOverlayRenderables();
// HACK: Keep old grouping behaviour
var groupedOverlayRenderables = finalOverlayRenderables.GroupBy(prs => prs.GetType());
foreach (var g in groupedOverlayRenderables)
{
foreach (var r in g)
{
r.Render(this);
}
}
if (debugVis.Value != null && debugVis.Value.RenderGeometry)
{
for (var i = 0; i < renderables.Count; i++)
{
renderables[i].RenderDebugGeometry(this);
}
foreach (var g in groupedOverlayRenderables)
{
foreach (var r in g)
{
r.RenderDebugGeometry(this);
}
}
}
if (debugVis.Value != null && debugVis.Value.ScreenMap)
{
foreach (var r in World.ScreenMap.RenderBounds(World.RenderPlayer))
{
Game.Renderer.WorldRgbaColorRenderer.DrawRect(
new float3(r.Left, r.Top, r.Bottom),
new float3(r.Right, r.Bottom, r.Bottom),
1 / Viewport.Zoom, Color.MediumSpringGreen);
}
foreach (var r in World.ScreenMap.MouseBounds(World.RenderPlayer))
{
Game.Renderer.WorldRgbaColorRenderer.DrawRect(
new float3(r.Left, r.Top, r.Bottom),
new float3(r.Right, r.Bottom, r.Bottom),
1 / Viewport.Zoom, Color.OrangeRed);
}
}
Game.Renderer.Flush();
// PERF: Reuse collection to avoid allocations.
onScreenActors.Clear();
}
/// <summary>
/// Resolve a relationship stanza (a list of relationships).
/// This will add modules to be installed, if required.
/// May recurse back to Resolve for those new modules.
///
/// If `soft_resolve` is true, we warn rather than throw exceptions on mods we cannot find.
/// If `soft_resolve` is false (default), we throw a ModuleNotFoundKraken if we can't find a dependency.
///
/// Throws a TooManyModsProvideKraken if we have too many choices and
/// options.without_toomanyprovides_kraken is not set.
///
/// See RelationshipResolverOptions for further adjustments that can be made.
/// </summary>
private void ResolveStanza(IEnumerable <RelationshipDescriptor> stanza, SelectionReason reason,
RelationshipResolverOptions options, bool soft_resolve = false, IEnumerable <RelationshipDescriptor> old_stanza = null)
{
if (stanza == null)
{
return;
}
stanza = stanza.Memoize();
foreach (RelationshipDescriptor descriptor in stanza)
{
log.DebugFormat("Considering {0}", descriptor.ToString());
// If we already have this dependency covered, skip.
if (descriptor.MatchesAny(modlist.Values, null, null))
{
continue;
}
else if (descriptor.ContainsAny(modlist.Keys))
{
CkanModule module = modlist.Values
.FirstOrDefault(m => descriptor.ContainsAny(new string[] { m.identifier }));
if (options.proceed_with_inconsistencies)
{
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(module, reason.Parent));
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(reason.Parent, module));
continue;
}
else
{
throw new InconsistentKraken(
$"{descriptor} required, but an incompatible version is in the resolver"
);
}
}
// If it's already installed, skip.
if (descriptor.MatchesAny(
registry.InstalledModules.Select(im => im.Module),
registry.InstalledDlls.ToHashSet(),
registry.InstalledDlc))
{
continue;
}
else if (descriptor.ContainsAny(registry.InstalledModules.Select(im => im.Module.identifier)))
{
CkanModule module = registry.InstalledModules
.Select(im => im.Module)
.FirstOrDefault(m => descriptor.ContainsAny(new string[] { m.identifier }));
if (options.proceed_with_inconsistencies)
{
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(module, reason.Parent));
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(reason.Parent, module));
continue;
}
else
{
throw new InconsistentKraken(
$"{descriptor} required, but an incompatible version is installed"
);
}
}
// Pass mod list in case an older version of a module is conflict-free while later versions have conflicts
var descriptor1 = descriptor;
List <CkanModule> candidates = descriptor
.LatestAvailableWithProvides(registry, kspversion, modlist.Values)
.Where(mod => descriptor1.WithinBounds(mod) && MightBeInstallable(mod))
.ToList();
if (candidates.Count == 0)
{
// Nothing found, try again without mod list
// (conflicts will still be caught below)
candidates = descriptor
.LatestAvailableWithProvides(registry, kspversion)
.Where(mod => descriptor1.WithinBounds(mod) && MightBeInstallable(mod))
.ToList();
}
if (candidates.Count == 0)
{
if (!soft_resolve)
{
log.InfoFormat("Dependency on {0} found but it is not listed in the index, or not available for your version of KSP.", descriptor.ToString());
throw new DependencyNotSatisfiedKraken(reason.Parent, descriptor.ToString());
}
log.InfoFormat("{0} is recommended/suggested but it is not listed in the index, or not available for your version of KSP.", descriptor.ToString());
continue;
}
if (candidates.Count > 1)
{
// Oh no, too many to pick from!
// TODO: It would be great if instead we picked the one with the
// most recommendations.
if (options.without_toomanyprovides_kraken)
{
continue;
}
// If we've got a parent stanza that has a relationship on a mod that provides what
// we need, then select that.
if (old_stanza != null)
{
List <CkanModule> provide = candidates
.Where(cand => old_stanza.Any(rel => rel.WithinBounds(cand)))
.ToList();
if (!provide.Any() || provide.Count() > 1)
{
//We still have either nothing, or too many to pick from
//Just throw the TMP now
throw new TooManyModsProvideKraken(descriptor.ToString(), candidates);
}
candidates[0] = provide.First();
}
else
{
throw new TooManyModsProvideKraken(descriptor.ToString(), candidates);
}
}
CkanModule candidate = candidates[0];
// Finally, check our candidate against everything which might object
// to it being installed; that's all the mods which are fixed in our
// list thus far, as well as everything on the system.
var fixed_mods = new HashSet <CkanModule>(modlist.Values);
fixed_mods.UnionWith(installed_modules);
CkanModule conflicting_mod = fixed_mods.FirstOrDefault(mod => mod.ConflictsWith(candidate));
if (conflicting_mod == null)
{
// Okay, looks like we want this one. Adding.
Add(candidate, reason);
Resolve(candidate, options, stanza);
}
else if (soft_resolve)
{
log.InfoFormat("{0} would cause conflicts, excluding it from consideration", candidate);
}
else
{
if (options.proceed_with_inconsistencies)
{
Add(candidate, reason);
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(conflicting_mod, candidate));
conflicts.Add(new KeyValuePair <CkanModule, CkanModule>(candidate, conflicting_mod));
}
else
{
throw new InconsistentKraken(
$"{conflicting_mod} conflicts with {candidate}");
}
}
}
}
