/// <summary>
/// Gets the application assemblies.
/// </summary>
/// <param name="assemblyFilter">(Optional) A filter for the assemblies.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A promise of an enumeration of application assemblies.
/// </returns>
public virtual async Task<IEnumerable<Assembly>> GetAppAssembliesAsync(Func<AssemblyName, bool> assemblyFilter = null, CancellationToken cancellationToken = default(CancellationToken))
{
// TODO The assemblies from the current domain do not consider the not loaded
// but required referenced assemblies. Therefore load all the references recursively.
// This could be optimized somehow.
var assemblies = this.GetLoadedAssemblies();
assemblyFilter = assemblyFilter ?? this.AssemblyFilter;
var loadedAssemblyRefs = new HashSet<string>(assemblies.Select(a => a.GetName().FullName));
var assembliesToCheck = assemblies.Where(a => assemblyFilter(a.GetName())).ToList();
while (assembliesToCheck.Count > 0)
{
var assemblyRefsToLoad = new HashSet<AssemblyName>();
foreach (var assembly in assembliesToCheck)
{
var referencesToLoad = this.GetReferencedAssemblies(assembly).Where(a => !loadedAssemblyRefs.Contains(a.FullName) && assemblyFilter(a));
assemblyRefsToLoad.AddRange(referencesToLoad);
}
loadedAssemblyRefs.AddRange(assemblyRefsToLoad.Select(an => an.FullName));
assembliesToCheck = assemblyRefsToLoad.Select(this.AssemblyLoader.LoadAssembly).ToList();
assemblies.AddRange(assembliesToCheck);
}
await this.AddAdditionalAssembliesAsync(assemblies, assemblyFilter, cancellationToken).PreserveThreadContext();
return assemblies;
}
public static ClaimsIdentity CreateUserIdentity(string emailAddress, string id, string[] organizationIds, string[] roles, string defaultProjectId = null) {
var claims = new List<Claim> {
new Claim(ClaimTypes.Name, emailAddress),
new Claim(ClaimTypes.NameIdentifier, id),
new Claim(OrganizationIdsClaim, String.Join(",", organizationIds))
};
if (!String.IsNullOrEmpty(defaultProjectId))
claims.Add(new Claim(DefaultProjectIdClaim, defaultProjectId));
var userRoles = new HashSet<string>(roles);
if (userRoles.Any()) {
// add implied scopes
if (userRoles.Contains(AuthorizationRoles.GlobalAdmin))
userRoles.Add(AuthorizationRoles.User);
if (userRoles.Contains(AuthorizationRoles.User))
userRoles.Add(AuthorizationRoles.Client);
claims.AddRange(userRoles.Select(scope => new Claim(ClaimTypes.Role, scope)));
} else {
claims.Add(new Claim(ClaimTypes.Role, AuthorizationRoles.Client));
claims.Add(new Claim(ClaimTypes.Role, AuthorizationRoles.User));
}
return new ClaimsIdentity(claims, UserAuthenticationType);
}
///<summary>Gets all files that indirectly depend on the specified file.</summary>
public async Task<IEnumerable<string>> GetRecursiveDependentsAsync(string fileName)
{
HashSet<GraphNode> visited;
fileName = Path.GetFullPath(fileName);
using (await rwLock.ReadLockAsync())
{
GraphNode rootNode;
if (!nodes.TryGetValue(fileName, out rootNode))
return Enumerable.Empty<string>();
var stack = new Stack<GraphNode>();
stack.Push(rootNode);
visited = new HashSet<GraphNode> { rootNode };
while (stack.Count > 0)
{
foreach (var child in stack.Pop().Dependents)
{
if (!visited.Add(child)) continue;
stack.Push(child);
}
}
// Don't return the original file.
visited.Remove(rootNode);
}
return visited.Select(n => n.FileName);
}
public void Install(RunningDeployment deployment)
{
var transformDefinitions = GetTransformDefinitions(deployment.Variables.Get(SpecialVariables.Package.AdditionalXmlConfigurationTransforms));
var sourceExtensions = new HashSet<string>(
transformDefinitions
.Where(transform => transform.Advanced)
.Select(transform => "*" + Path.GetExtension(transform.SourcePattern))
.Distinct()
);
if (deployment.Variables.GetFlag(SpecialVariables.Package.AutomaticallyRunConfigurationTransformationFiles))
{
sourceExtensions.Add("*.config");
transformDefinitions.Add(new XmlConfigTransformDefinition("Release"));
var environment = deployment.Variables.Get(SpecialVariables.Environment.Name);
if (!string.IsNullOrWhiteSpace(environment))
{
transformDefinitions.Add(new XmlConfigTransformDefinition(environment));
}
}
var transformsRun = new HashSet<Tuple<string, string>>();
foreach (var configFile in fileSystem.EnumerateFilesRecursively(deployment.CurrentDirectory, sourceExtensions.ToArray()))
{
ApplyTransformations(configFile, transformDefinitions, transformsRun);
}
deployment.Variables.SetStrings(SpecialVariables.AppliedXmlConfigTransforms, transformsRun.Select(t => t.Item1), "|");
}
public static ClaimsIdentity ToIdentity(this User user, string defaultProjectId = null) {
if (user == null)
return WindowsIdentity.GetAnonymous();
var claims = new List<Claim> {
new Claim(ClaimTypes.Name, user.EmailAddress),
new Claim(ClaimTypes.NameIdentifier, user.Id),
new Claim(OrganizationIdsClaim, String.Join(",", user.OrganizationIds.ToArray()))
};
if (!String.IsNullOrEmpty(defaultProjectId))
claims.Add(new Claim(DefaultProjectIdClaim, defaultProjectId));
var userRoles = new HashSet<string>(user.Roles.ToArray());
if (userRoles.Any()) {
// add implied scopes
if (userRoles.Contains(AuthorizationRoles.GlobalAdmin))
userRoles.Add(AuthorizationRoles.User);
if (userRoles.Contains(AuthorizationRoles.User))
userRoles.Add(AuthorizationRoles.Client);
claims.AddRange(userRoles.Select(scope => new Claim(ClaimTypes.Role, scope)));
} else {
claims.Add(new Claim(ClaimTypes.Role, AuthorizationRoles.Client));
claims.Add(new Claim(ClaimTypes.Role, AuthorizationRoles.User));
}
return new ClaimsIdentity(claims, UserAuthenticationType);
}
/// <summary> Converts a console file args into actual files. </summary>
/// <remarks> Sequences like "test.vsdx *.vsdx .\test.vsdx" will be correctly recognized,
/// no file duplicates will be created. </remarks>
/// <param name="passedFileArgs">File arguments in the console input.</param>
/// <returns>Sequence of files recognized in the console input.</returns>
public static IEnumerable<FileInfo> GatherFiles(IList<string> passedFileArgs)
{
// Expand passed console input with possible wildcards and duplications into real unique file names:
var expandedPaths = new HashSet<string>();
foreach (var inputItem in passedFileArgs) {
if (string.IsNullOrWhiteSpace(inputItem)) { continue; }
string[] files;
if (Directory.Exists(inputItem)) {
files = GetFiles(inputItem);
} else {
string path = Path.GetDirectoryName(inputItem);
string filename = Path.GetFileName(inputItem);
if (filename == "*") {
filename = "*.*";
}
files = GetFiles(path, filename);
}
foreach (var file in files) {
expandedPaths.Add(file);
}
}
// Expanded file names can be safely turned into FileInfos, since GetFiles()
// only return real files which can be accessed.
return expandedPaths.Select(expandedPath => new FileInfo(expandedPath));
}
public void MatchIndex()
{
string tournamentName = "ChallongeNet" + Utilities.RandomName();
Debug.WriteLine(string.Format("Initializing with name {0}", tournamentName));
var tournamentUnderTest = this.target.TournamentCreate(tournamentName, TournamentType.SingleElimination, tournamentName);
var participantNames = new HashSet<string>();
const int NumberOfParticipants = 8;
while (participantNames.Count < NumberOfParticipants)
{
string name = "ChallongeNet" + Utilities.RandomName();
participantNames.Add(name);
}
var participants = participantNames.Select(name => this.target.ParticipantCreate(tournamentUnderTest, new ParticipantCreateParameters { Name = name })).ToList();
tournamentUnderTest = this.target.TournamentStart(tournamentUnderTest);
var participant = participants.First();
var parameters = new MatchIndexParameters { ParticipantId = participant.Id };
var matches = this.target.MatchIndex(tournamentUnderTest, parameters);
var m = matches.Where(match => match.Player1Id == participant.Id || match.Player2Id == participant.Id);
Assert.AreEqual(1, m.Count());
parameters = new MatchIndexParameters { State = MatchIndexParameters.MatchIndexState.complete };
matches = this.target.MatchIndex(tournamentUnderTest, parameters);
Assert.AreEqual(0, matches.Count);
this.target.TournamentDestroy(tournamentUnderTest);
}
public ReplayViewModel Get([FromUri]string[] ids)
{
var heads = new[]
{
new Directed {X = 1, Y = 13, Direction = Direction.East},
new Directed {X = 25, Y = 13, Direction = Direction.West},
new Directed {X = 13, Y = 1, Direction = Direction.North},
new Directed {X = 13, Y = 25, Direction = Direction.South}
};
var n = 0;
var unique = new HashSet<string>(ids);
var fighters = unique
.Select(id => snakeStore.GetById(id))
.Where(s => s != null)
.Take(4)
.Select(snake => new Fighter(snake.Id, snake.Chips, heads[n++]))
.ToList();
var tickCount = Environment.TickCount;
var replay = new Replay(tickCount) { BattleField = new BattleField() };
if (fighters.Count > 0)
{
var battleField = new BattleField();
var battleManager = new BattleManager(fighters, replay, new FieldComparer(battleField), battleField, tickCount);
battleManager.Fight(550); //original 550
}
var model = Mapper.Map<Replay, ReplayViewModel>(replay);
return model;
}
public bool MapCanBeSolved()
{
var cluesFound = new HashSet<Clue>();
var doorManager = model.DoorAndClueManager;
//Door & Clue manager works on the reduced map, so we use this here
//Potentially could be problematic if something is wrong with map reduction
var totalVerticesReducedMap = model.GraphNoCycles.mapNoCycles.VertexCount;
int lastTimeAccessibleVertices = 0;
int noAccessibleVertices = 0;
do
{
lastTimeAccessibleVertices = noAccessibleVertices;
var accessibleVertices = doorManager.GetAccessibleVerticesWithClues(cluesFound.Select(c => c.OpenLockIndex));
//Add any clues in these vertices to the clues we have (hashset ensures we don't add twice)
var cluesAtVertices = accessibleVertices.SelectMany(v => doorManager.ClueMap.ContainsKey(v) ? doorManager.ClueMap[v] : new List<Clue> ());
foreach (var clue in cluesAtVertices) { cluesFound.Add(clue); }
noAccessibleVertices = accessibleVertices.Count();
} while (noAccessibleVertices != lastTimeAccessibleVertices);
//Couldn't touch all vertices - map is not solvable
if (noAccessibleVertices < totalVerticesReducedMap)
return false;
return true;
}
private static void Main(string[] args)
{
int t = int.Parse(Console.ReadLine());
string[] k = new string[t];
for (int i = 0; i < k.Length; i++)
{
k[i] = Console.ReadLine();
}
string temp = @"<[ ]{0,}[a-z]{1,}[\d]{0,}";
var regex = new Regex(temp);
HashSet<string> rez = new HashSet<string>();
for (int i = 0; i < k.Length; i++)
{
var matchs = regex.Matches(k[i]);
foreach (var r in matchs)
{
var match = (Match)r;
rez.Add(match.Value);
}
}
var s = rez
.Select(f=>f.Substring(1))
.ToArray();
Array.Sort(s);
string mimimi = string.Join(";", s);
Console.Write(mimimi);
}
protected ApprovalProcess(Guid promotionId, HashSet<Editor> editors)
{
Id = Guid.NewGuid();
PromotionId = promotionId;
Status = ApprovalStatus.Pending;
ApprovalRequests = editors.Select(e => new ApprovalRequest(e)).ToList();
}
public static UnifiedBubbleGroup CreateUnified(List<BubbleGroup> groups, BubbleGroup primaryGroup)
{
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroupsToKill = new HashSet<UnifiedBubbleGroup>();
foreach (var group in groups)
{
if (group.IsUnified)
{
unifiedGroupsToKill.Add(group.Unified);
@group.DeregisterUnified();
}
}
foreach (var unifiedGroup in unifiedGroupsToKill)
{
BubbleGroupManager.BubbleGroupsRemove(unifiedGroup);
}
BubbleGroupIndex.RemoveUnified(unifiedGroupsToKill.Select(x => x.ID).ToArray());
var unified = CreateUnifiedInternal(groups, primaryGroup);
BubbleGroupIndex.AddUnified(unified);
BubbleGroupManager.BubbleGroupsAdd(unified);
return unified;
}
}
public void onProductListReceived (string productListString) {
if (productListString.Length == 0) {
biller.logError (UnibillError.STOREKIT_RETURNED_NO_PRODUCTS);
biller.onSetupComplete (false);
return;
}
Dictionary<string, object> response = (Dictionary<string, object>)Unibill.Impl.MiniJSON.jsonDecode(productListString);
HashSet<PurchasableItem> productsReceived = new HashSet<PurchasableItem>();
foreach (var identifier in response.Keys) {
var item = remapper.getPurchasableItemFromPlatformSpecificId(identifier.ToString());
Dictionary<string, object> details = (Dictionary<string, object>)response[identifier];
PurchasableItem.Writer.setLocalizedPrice(item, details["price"].ToString());
PurchasableItem.Writer.setLocalizedTitle(item, details["localizedTitle"].ToString());
PurchasableItem.Writer.setLocalizedDescription(item, details["localizedDescription"].ToString());
productsReceived.Add(item);
}
HashSet<PurchasableItem> productsNotReceived = new HashSet<PurchasableItem> (products);
productsNotReceived.ExceptWith (productsReceived);
if (productsNotReceived.Count > 0) {
foreach (PurchasableItem product in productsNotReceived) {
biller.logError(UnibillError.STOREKIT_REQUESTPRODUCTS_MISSING_PRODUCT, product.Id, remapper.mapItemIdToPlatformSpecificId(product));
}
}
this.productsNotReturnedByStorekit = new HashSet<string>(productsNotReceived.Select(x => remapper.mapItemIdToPlatformSpecificId(x)));
// We should complete so long as we have at least one purchasable product.
biller.onSetupComplete(true);
}
private SyntaxNode AddNamespaceImports(
Document document,
SemanticModel model,
OptionSet options,
IEnumerable<INamespaceSymbol> namespaces)
{
var existingNamespaces = new HashSet<INamespaceSymbol>();
this.GetExistingImportedNamespaces(document, model, existingNamespaces);
var namespacesToAdd = new HashSet<INamespaceSymbol>(namespaces);
namespacesToAdd.RemoveAll(existingNamespaces);
var root = model.SyntaxTree.GetRoot();
if (namespacesToAdd.Count == 0)
{
return root;
}
var gen = SyntaxGenerator.GetGenerator(document);
var newRoot = root;
foreach (var import in namespacesToAdd.Select(ns => gen.NamespaceImportDeclaration(ns.ToDisplayString()).WithAdditionalAnnotations(Simplifier.Annotation)))
{
newRoot = this.InsertNamespaceImport(newRoot, gen, import, options);
}
return newRoot;
}
public static int Circulars(int range)
{
int count = 0;
HashSet<int> primes = new HashSet<int>();
primes.UnionWith(Primes.primeRange(range));
HashSet<string> stringprimes = new HashSet<string>();
stringprimes.UnionWith(primes.Select<int, string>(x => x.ToString()));
stringprimes.RemoveWhere(x => x.Contains('2') || x.Contains('4') || x.Contains('6') || x.Contains('8') || x.Contains('0'));
foreach (string number in stringprimes) {
string varnumber = number.Substring(0);
bool allPrime = true;
for (int i = 0; i < number.Length; i++) {
char c = varnumber.First<char>();
varnumber += c;
varnumber = varnumber.Remove(0, 1);
if (!primes.Contains(int.Parse(varnumber))) {
//Console.WriteLine(number);
allPrime = false;
break;
}
}
if (allPrime == true) {
count++;
}
allPrime = true;
}
return count + 1;
}
/// <summary>
/// Retrieves all events across all aggregates that are related to the specified aggregate ids, in the order in which they were recorded.
/// </summary>
/// <param name="events">The events.</param>
/// <param name="relatedToAggregateIds">The aggregate ids to which the events relate.</param>
public static async Task<IEnumerable<StorableEvent>> RelatedEvents(
this IQueryable<StorableEvent> events,
params Guid[] relatedToAggregateIds)
{
var ids = new HashSet<Guid>(relatedToAggregateIds);
var relatedEvents = new HashSet<StorableEvent>();
int currentCount;
do
{
currentCount = relatedEvents.Count;
var unqueriedIds = ids.Where(id => ! relatedEvents.Select(e => e.AggregateId).Contains(id));
var newEvents = await events.Where(e => unqueriedIds.Any(id => id == e.AggregateId)).ToArrayAsync();
relatedEvents.UnionWith(newEvents);
var moreIds = newEvents
.SelectMany(e => e.Body.ExtractGuids())
.Distinct()
.ToArray();
if (!moreIds.Any())
{
break;
}
ids.UnionWith(moreIds);
} while (currentCount != relatedEvents.Count);
return relatedEvents.OrderBy(e => e.Id);
}
private async Task<SyntaxNode> AddNamespaceImportsAsync(
Document document,
SemanticModel model,
OptionSet options,
IEnumerable<INamespaceSymbol> namespaces,
CancellationToken cancellationToken)
{
var existingNamespaces = new HashSet<INamespaceSymbol>();
await this.GetExistingImportedNamespacesAsync(document, model, existingNamespaces, cancellationToken).ConfigureAwait(false);
var namespacesToAdd = new HashSet<INamespaceSymbol>(namespaces);
namespacesToAdd.RemoveAll(existingNamespaces);
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
if (namespacesToAdd.Count == 0)
{
return root;
}
var gen = SyntaxGenerator.GetGenerator(document);
var newRoot = root;
foreach (var import in namespacesToAdd.Select(ns => gen.NamespaceImportDeclaration(ns.ToDisplayString()).WithAdditionalAnnotations(Simplifier.Annotation)))
{
newRoot = this.InsertNamespaceImport(newRoot, gen, import, options);
}
return newRoot;
}
public static void SomeFunction()
{
Dictionary<int, int> dict = new Dictionary<int, int>();
dict.Add(4, 3);
Console.WriteLine(dict[4]);
Console.WriteLine(dict.ContainsKey(8));
dict.Remove(4);
foreach(int key in dict.Keys)
Console.WriteLine(key);
foreach(int val in dict.Values)
Console.WriteLine(val);
foreach(var kv in dict)
Console.WriteLine(kv.Key + " " + kv.Value);
var dict2 = dict.ToDictionary(o => o.Key, o => o.Value);
var vals = dict.Values;
HashSet<int> hash = new HashSet<int>();
hash.Add(999);
Console.WriteLine(hash.Contains(999));
hash.Remove(999);
Console.WriteLine(hash.Contains(999));
foreach(int hashItem in hash)
Console.WriteLine(hashItem);
var z = hash.Select(o => 3).ToArray();
var g = hash.GroupBy(o => o).Select(o => o.Count()).Min();
}
internal Assembly CompileAndLoadClassDefinition(string code, string className, HashSet<string> assemblies)
{
using (var ms = new MemoryStream())
{
string assemblyFileName = className + Guid.NewGuid().ToString().Replace("-", "") + ".dll";
assemblies.Add(typeof(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException).Assembly.Location);
var references = assemblies.Select(a => MetadataReference.CreateFromFile(a));
var compilation = CSharpCompilation.Create(assemblyFileName,
new[] { CSharpSyntaxTree.ParseText(code) }, references,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary
//#if !DEBUG
//, optimizationLevel: OptimizationLevel.Release
//#endif
));
var result = compilation.Emit(ms);
if (!result.Success)
{
var errors = string.Join(Environment.NewLine, result.Diagnostics);
throw new Exception("Unable to compile. Errors:" + Environment.NewLine + errors);
}
var assembly = Assembly.Load(ms.GetBuffer());
return assembly;
}
}
/// <summary>
/// Returns a list of assemblies that need binding redirects.
/// </summary>
/// <param name="assemblies">List assemblies to analyze for binding redirects</param>
public static IEnumerable<AssemblyBinding> GetBindingRedirects(IEnumerable<IAssembly> assemblies)
{
if (assemblies == null) {
throw new ArgumentNullException("assemblies");
}
// Evaluate the list eagerly
var assemblyList = assemblies.ToList();
var assemblyNameLookup = assemblyList.ToDictionary(GetUniqueKey);
// Output set of assemblies we need redirects for
var redirectAssemblies = new HashSet<IAssembly>();
// For each available assembly
foreach (IAssembly assembly in assemblyList) {
foreach (IAssembly referenceAssembly in assembly.ReferencedAssemblies) {
Tuple<string, string> key = GetUniqueKey(referenceAssembly);
IAssembly targetAssembly;
// If we have an assembly with the same unique key in our list of a different version then we want to use that version
// then we want to add a redirect for that assembly
if (assemblyNameLookup.TryGetValue(key, out targetAssembly) && targetAssembly.Version != referenceAssembly.Version) {
redirectAssemblies.Add(targetAssembly);
}
}
}
return redirectAssemblies.Select(a => new AssemblyBinding(a));
}
public IList<HtmlCompletion> GetEntries(HtmlCompletionContext context)
{
var list = new HashSet<string>();
context.Document.HtmlEditorTree.RootNode.Accept(this, list);
return new List<HtmlCompletion>(list.Select(s => new SimpleHtmlCompletion(s, context.Session)));
}
public IList<HtmlCompletion> GetEntries(HtmlCompletionContext context)
{
var list = new HashSet<string>();
var glyph = GlyphService.GetGlyph(StandardGlyphGroup.GlyphGroupVariable, StandardGlyphItem.GlyphItemPublic);
context.Document.HtmlEditorTree.RootNode.Accept(this, list);
return list.Select(s => new HtmlCompletion(s, s, s, glyph, HtmlIconAutomationText.AttributeIconText)).ToList();
}
public string[] GetAllProjectReferences(string projectName)
{
var project = Solution.Projects.First(x => x.Name == projectName);
var allReferences = new HashSet<MetadataReference>();
PopulateWithReferences(allReferences, project);
return allReferences.Select(x => x.Display).ToArray();
}
/// <summary>
/// Calculate a path from the start location to the destination location
/// </summary>
/// <remarks>
/// Based on the A* pathfinding algorithm described on Wikipedia
/// </remarks>
/// <see href="https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode"/>
/// <param name="start">Start location</param>
/// <param name="goal">Destination location</param>
/// <param name="allowUnsafe">Allow possible but unsafe locations</param>
/// <returns>A list of locations, or null if calculation failed</returns>
public static Queue<Location> CalculatePath(World world, Location start, Location goal, bool allowUnsafe = false)
{
Queue<Location> result = null;
AutoTimeout.Perform(() =>
{
HashSet<Location> ClosedSet = new HashSet<Location>(); // The set of locations already evaluated.
HashSet<Location> OpenSet = new HashSet<Location>(new[] { start }); // The set of tentative nodes to be evaluated, initially containing the start node
Dictionary<Location, Location> Came_From = new Dictionary<Location, Location>(); // The map of navigated nodes.
Dictionary<Location, int> g_score = new Dictionary<Location, int>(); //:= map with default value of Infinity
g_score[start] = 0; // Cost from start along best known path.
// Estimated total cost from start to goal through y.
Dictionary<Location, int> f_score = new Dictionary<Location, int>(); //:= map with default value of Infinity
f_score[start] = (int)start.DistanceSquared(goal); //heuristic_cost_estimate(start, goal)
while (OpenSet.Count > 0)
{
Location current = //the node in OpenSet having the lowest f_score[] value
OpenSet.Select(location => f_score.ContainsKey(location)
? new KeyValuePair<Location, int>(location, f_score[location])
: new KeyValuePair<Location, int>(location, int.MaxValue))
.OrderBy(pair => pair.Value).First().Key;
if (current == goal)
{ //reconstruct_path(Came_From, goal)
List<Location> total_path = new List<Location>(new[] { current });
while (Came_From.ContainsKey(current))
{
current = Came_From[current];
total_path.Add(current);
}
total_path.Reverse();
result = new Queue<Location>(total_path);
}
OpenSet.Remove(current);
ClosedSet.Add(current);
foreach (Location neighbor in GetAvailableMoves(world, current, allowUnsafe))
{
if (ClosedSet.Contains(neighbor))
continue; // Ignore the neighbor which is already evaluated.
int tentative_g_score = g_score[current] + (int)current.DistanceSquared(neighbor); //dist_between(current,neighbor) // length of this path.
if (!OpenSet.Contains(neighbor)) // Discover a new node
OpenSet.Add(neighbor);
else if (tentative_g_score >= g_score[neighbor])
continue; // This is not a better path.
// This path is the best until now. Record it!
Came_From[neighbor] = current;
g_score[neighbor] = tentative_g_score;
f_score[neighbor] = g_score[neighbor] + (int)neighbor.DistanceSquared(goal); //heuristic_cost_estimate(neighbor, goal)
}
}
}, TimeSpan.FromSeconds(5));
return result;
}
private Entry PickOtherMethod(HashSet<Entry> except)
{
var except2 = new HashSet<string>(except.Select(e => e.OptUnitID));
var randomUnit = Units[RandomGenerator.Random.Next(Units.Count)];
while (except2.Contains(randomUnit.ID))
{
randomUnit = Units[RandomGenerator.Random.Next(Units.Count)];
}
return new Entry(randomUnit.ID, randomUnit.CreateContext());
}
public IMapa Przetwarzaj(HashSet<VoronoiEdge> krawedzieWoronoja)
{
_komorkiZVectorami = new Dictionary<Vector, IKomorka>();
_rogiZVectorami = new Dictionary<Vector, IRog>();
Mapa.Dwukrawedzie = krawedzieWoronoja.Select(woro => UtworzDwukrawedz(woro)).ToList();
UstawKomorkomPrzylegle();
UstawRogomBliskich();
Mapa.ZakonczonoTworzenie = true;
return Mapa;
}
protected override bool TickCore(RealmTime time)
{
var entities = GetNearestEntities(28, 0x0d5e)
.Concat(GetNearestEntities(28, 0x0d60))
.ToArray();
if (entities.Length != 5)
return true;
var packets = new List<Packet>();
var owner = Host.Self.Owner;
if (entities.All(_ => _.ObjectType != 0x0d5e))
{
var players = new HashSet<Entity>();
foreach (var i in entities.SelectMany(_ => (_ as Enemy).DamageCounter.GetPlayerData()).Where(i => i.Item1.Quest == Host))
players.Add(i.Item1);
packets.AddRange(players.Select(i => new NotificationPacket
{
ObjectId = i.Id, Color = new ARGB(0xFF00FF00), Text = "Quest Complete!"
}));
if (Host.Self.Owner is GameWorld)
(Host.Self.Owner as GameWorld).EnemyKilled(Host as Enemy,
(entities.Last() as Enemy).DamageCounter.Parent.LastHitter);
Despawn.Instance.Tick(Host, time);
foreach (var i in entities)
Die.Instance.Tick(i, time);
}
else
{
var hasCorpse = entities.Any(_ => _.ObjectType == 0x0d60);
for (var i = 0; i < entities.Length; i++)
for (var j = i + 1; j < entities.Length; j++)
{
packets.Add(new ShowEffectPacket
{
TargetId = entities[i].Id,
EffectType = EffectType.Stream,
Color = new ARGB(hasCorpse ? 0xffffff00 : 0xffff0000),
PosA = new Position
{
X = entities[j].X,
Y = entities[j].Y
},
PosB = new Position
{
X = entities[i].X,
Y = entities[i].Y
}
});
}
}
owner.BroadcastPackets(packets, null);
return true;
}
public static IEnumerable<VocabularyItem> GenerateVocabulary(InputSettings settings)
{
var words = new HashSet<string>();
while (words.Count < settings.VocabularySize)
words.Add(GenerateOneWord(settings.WordMaxLength));
Func<int> genOccurrence = () => _st_random.Next(settings.WordMaxOccurrences + 1);
return words
.Select(word => new VocabularyItem(word, genOccurrence()))
.ToArray();
}
public IList<HtmlCompletion> GetEntries(HtmlCompletionContext context)
{
var list = new HashSet<string>();
if (context.Element != null && _inputTypes.Contains(context.Element.Name))
{
context.Document.HtmlEditorTree.RootNode.Accept(this, list);
}
return new List<HtmlCompletion>(list.Select(s => new SimpleHtmlCompletion(s, context.Session)));
}
private static void Print(NodeExt[] workers, int sec, HashSet <NodeExt> done)
{
const int width = -5;
Console.Write($"{sec,width}");
for (int i = 1; i <= workers.Length; i++)
{
Console.Write($"{workers[i - 1]?.Label ?? '.',width}");
}
Console.WriteLine(string.Join(", ", done?.Select(l => l.Label)));
}
public static string GetUsersString(HashSet<Guid> users)
{
var usersString = users.Select(GetUser)
.Aggregate(string.Empty, (current, user) => current + (user.DisplayName + ", "));
if (!string.IsNullOrEmpty(usersString))
{
usersString = usersString.Remove(usersString.Length - 2);
}
return usersString;
}
public void Setup(IActivityMonitor monitor)
{
using (monitor.OpenInfo($"Executing {_scripts.Count} script(s) on this Workstation."))
using (var tempPS1 = new TemporaryFile("ps1"))
{
bool hasError = false;
HashSet <EnvVar> currentVariables = null;
foreach (var o in _scripts)
{
if (hasError)
{
break;
}
switch (o)
{
case HashSet <EnvVar> v: currentVariables = v; break;
case ScriptLine script:
{
using (monitor.OpenTrace($"Executing script Type='{script.Type}', WorkingDir='{script.WorkingDir}', Arguments='{script.Arguments}', ContinueOnNonZeroExitCode='{script.ContinueOnNonZeroExitCode}'."))
{
monitor.Debug($"With EnvironmentVariables: {currentVariables?.Select( v => v.ToString() ).Concatenate()}.");
monitor.Debug(script.Script);
var variables = currentVariables?.Select(v => (v.Name, Environment.ExpandEnvironmentVariables(v.Value))).ToList()
?? new List <(string Name, string)>();
variables.Add(("CKLI_WORLD_MAPPING", _fileSystem.Root));
System.IO.File.WriteAllText(tempPS1.Path, script.Script);
if (!ProcessRunner.RunPowerShell(
monitor,
script.WorkingDir,
tempPS1.Path,
new[] { script.Arguments },
stdErrorLevel: LogLevel.Warn,
variables))
{
hasError |= !script.ContinueOnNonZeroExitCode;
if (!hasError)
{
monitor.Warn("ContinueOnNonZeroExitCode is true: error is ignored.");
}
}
}
break;
}
}
}
}
}
public IEnumerable <ResourceRecord> FindResponse(Question question)
{
HashSet <SerializableResourceRecord> cachedResourceRecords = null;
var questionName = $"{question.Name} {question.Type}";
if (cachedRecords.ContainsKey(questionName))
{
cachedResourceRecords = cachedRecords[questionName];
}
return(cachedResourceRecords?.Select(cachedRecordValue => new ResourceRecord(
cachedRecordValue.Name, cachedRecordValue.Data,
cachedRecordValue.Type, cachedRecordValue.Class,
cachedRecordValue.TimeToLive)));
}
private async Task FillDescriptionUsedEntities(StringBuilder strFile, HashSet <Guid> workflowsWithEntities, Dictionary <EntityReference, HashSet <Guid> > dictUsedEntities)
{
string message = string.Empty;
if (dictUsedEntities.Count == 0)
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(this._iWriteToOutput.WriteToOutput(_service.ConnectionData, "No used entities in workflows."))
;
return;
}
strFile
.AppendLine()
.AppendLine()
.AppendFormat(this._iWriteToOutput.WriteToOutput(_service.ConnectionData, "Used Entities {0}", dictUsedEntities.Count)).AppendLine()
;
var orderedList = dictUsedEntities.Keys.OrderBy(i => i.LogicalName).ThenBy(i => i.Name).ThenBy(i => i.Id);
{
var table = new FormatTextTableHandler(
nameof(EntityReference.LogicalName)
, nameof(EntityReference.Name)
, nameof(EntityReference.Id)
, "Url"
);
foreach (var item in orderedList)
{
var values = new List <string>()
{
item.LogicalName, item.Name, item.Id.ToString()
};
var url = _service.ConnectionData.GetEntityInstanceUrl(item.LogicalName, item.Id);
if (!string.IsNullOrEmpty(url))
{
values.Add(url);
}
table.AddLine(values);
}
table.GetFormatedLines(false).ForEach(s => strFile.AppendLine(tabspacer + s));
}
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
.AppendLine()
.AppendLine()
.AppendLine()
;
strFile.AppendFormat("Used Entities Full Information {0}", dictUsedEntities.Count).AppendLine();
foreach (var item in orderedList)
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
;
var table = new FormatTextTableHandler();
table.SetHeader(nameof(EntityReference.LogicalName), nameof(EntityReference.Name), nameof(EntityReference.Id));
table.AddLine(item.LogicalName, item.Name, item.Id.ToString());
table.GetFormatedLines(false).ForEach(s => strFile.AppendLine(s));
var url = _service.ConnectionData.GetEntityInstanceUrl(item.LogicalName, item.Id);
if (!string.IsNullOrEmpty(url))
{
strFile.AppendLine("Url:");
strFile.AppendLine(url);
}
strFile.AppendLine();
try
{
var entityMetadata = _descriptor.MetadataSource.GetEntityMetadata(item.LogicalName);
if (entityMetadata != null)
{
var repositoryGeneric = new GenericRepository(_service, entityMetadata);
var entity = await repositoryGeneric.GetEntityByIdAsync(item.Id, ColumnSetInstances.AllColumns);
if (entity != null)
{
var desc = await EntityDescriptionHandler.GetEntityDescriptionAsync(entity, _service.ConnectionData);
strFile
.AppendLine(desc)
.AppendLine()
.AppendLine()
;
}
else
{
strFile
.AppendFormat("{0} With Id = {1} Does Not Exists", item.LogicalName, item.Id).AppendLine()
.AppendLine()
.AppendLine()
;
}
}
else
{
strFile
.AppendFormat("Entity with name '{0}' Does Not Exists", item.LogicalName).AppendLine()
.AppendFormat("{0} With Id = {1} Does Not Exists", item.LogicalName, item.Id).AppendLine()
.AppendLine()
.AppendLine()
;
}
}
catch (Exception ex)
{
var description = DTEHelper.GetExceptionDescription(ex);
strFile
.AppendLine(description)
.AppendLine()
.AppendLine()
;
}
message = await _descriptor.GetSolutionComponentsDescriptionAsync(dictUsedEntities[item].Select(id => new SolutionComponent()
{
ObjectId = id,
ComponentType = new OptionSetValue((int)ComponentType.Workflow),
}));
strFile
.AppendLine("This entity Used By Workflows:")
.AppendLine(message)
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
;
}
if (workflowsWithEntities.Any())
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine("These entities Used By Workflows:")
;
message = await _descriptor.GetSolutionComponentsDescriptionAsync(workflowsWithEntities.Select(id => new SolutionComponent()
{
ObjectId = id,
ComponentType = new OptionSetValue((int)ComponentType.Workflow),
}));
strFile.AppendLine(message);
}
}
internal static UdonBehaviour[] ConvertToUdonBehavioursInternal(UdonSharpBehaviour[] components, bool shouldUndo, bool showPrompts)
{
components = components.Distinct().ToArray();
bool convertChildren = true;
if (showPrompts)
{
HashSet <UdonSharpBehaviour> allReferencedBehaviours = new HashSet <UdonSharpBehaviour>();
// Check if any of these need child component conversion
foreach (UdonSharpBehaviour targetObject in components)
{
HashSet <UdonSharpBehaviour> referencedBehaviours = new HashSet <UdonSharpBehaviour>();
CollectUdonSharpBehaviourReferencesInternal(targetObject, referencedBehaviours);
if (referencedBehaviours.Count > 1)
{
foreach (UdonSharpBehaviour referencedBehaviour in referencedBehaviours)
{
if (referencedBehaviour != targetObject)
{
allReferencedBehaviours.Add(referencedBehaviour);
}
}
}
}
if (allReferencedBehaviours.Count > 0)
{
// This is an absolute mess, it should probably just be simplified to counting the number of affected behaviours
string referencedBehaviourStr;
if (allReferencedBehaviours.Count <= 2)
{
referencedBehaviourStr = string.Join(", ", allReferencedBehaviours.Select(e => $"'{e.ToString()}'"));
}
else
{
referencedBehaviourStr = $"{allReferencedBehaviours.Count} behaviours";
}
string rootBehaviourStr;
if (components.Length <= 2)
{
rootBehaviourStr = $"{string.Join(", ", components.Select(e => $"'{e.ToString()}'"))} reference{(components.Length == 1 ? "s" : "")} ";
}
else
{
rootBehaviourStr = $"{components.Length} behaviours to convert reference ";
}
string messageStr = $"{rootBehaviourStr}{referencedBehaviourStr}. Do you want to convert all referenced behaviours as well? If no, references to these behaviours will be set to null.";
int result = EditorUtility.DisplayDialogComplex("Dependent behaviours found", messageStr, "Yes", "Cancel", "No");
if (result == 2) // No
{
convertChildren = false;
}
else if (result == 1) // Cancel
{
return(null);
}
}
}
if (shouldUndo)
{
Undo.RegisterCompleteObjectUndo(components, "Convert to UdonBehaviour");
}
List <UdonBehaviour> createdComponents = new List <UdonBehaviour>();
foreach (UdonSharpBehaviour targetObject in components)
{
MonoScript behaviourScript = MonoScript.FromMonoBehaviour(targetObject);
UdonSharpProgramAsset programAsset = GetUdonSharpProgramAsset(behaviourScript);
if (programAsset == null)
{
if (showPrompts)
{
string scriptPath = AssetDatabase.GetAssetPath(behaviourScript);
string scriptDirectory = Path.GetDirectoryName(scriptPath);
string scriptFileName = Path.GetFileNameWithoutExtension(scriptPath);
string assetPath = Path.Combine(scriptDirectory, $"{scriptFileName}.asset").Replace('\\', '/');
if (EditorUtility.DisplayDialog("No linked program asset", $"There was no UdonSharpProgramAsset found for '{behaviourScript.GetClass()}', do you want to create one?", "Ok", "Cancel"))
{
if (AssetDatabase.LoadAssetAtPath <UdonSharpProgramAsset>(assetPath) != null)
{
if (!EditorUtility.DisplayDialog("Existing file found", $"Asset file {assetPath} already exists, do you want to overwrite it?", "Ok", "Cancel"))
{
continue;
}
}
}
else
{
continue;
}
programAsset = ScriptableObject.CreateInstance <UdonSharpProgramAsset>();
programAsset.sourceCsScript = behaviourScript;
AssetDatabase.CreateAsset(programAsset, assetPath);
AssetDatabase.SaveAssets();
UdonSharpProgramAsset.ClearProgramAssetCache();
programAsset.CompileCsProgram();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
}
else
{
Debug.LogWarning($"Could not convert U# behaviour '{behaviourScript.GetClass()}' on '{targetObject.gameObject}' because it does not have a corresponding UdonSharpProgramAsset");
continue;
}
}
GameObject targetGameObject = targetObject.gameObject;
UdonBehaviour udonBehaviour = null;
if (shouldUndo)
{
udonBehaviour = Undo.AddComponent <UdonBehaviour>(targetGameObject);
}
else
{
udonBehaviour = targetGameObject.AddComponent <UdonBehaviour>();
}
udonBehaviour.programSource = programAsset;
//if (shouldUndo)
// Undo.RegisterCompleteObjectUndo(targetObject, "Convert C# to U# behaviour");
UdonSharpEditorUtility.SetBackingUdonBehaviour(targetObject, udonBehaviour);
try
{
if (convertChildren)
{
UdonSharpEditorUtility.CopyProxyToUdon(targetObject, shouldUndo ? ProxySerializationPolicy.AllWithCreateUndo : ProxySerializationPolicy.All);
}
else
{
UdonSharpEditorUtility.CopyProxyToUdon(targetObject, ProxySerializationPolicy.RootOnly);
}
}
catch (System.Exception e)
{
Debug.LogError(e);
}
UdonSharpEditorUtility.SetBackingUdonBehaviour(targetObject, null);
System.Type behaviourType = targetObject.GetType();
UdonSharpBehaviour newProxy;
SetIgnoreEvents(true);
try
{
if (shouldUndo)
{
newProxy = (UdonSharpBehaviour)Undo.AddComponent(targetObject.gameObject, behaviourType);
}
else
{
newProxy = (UdonSharpBehaviour)targetObject.gameObject.AddComponent(behaviourType);
}
UdonSharpEditorUtility.SetBackingUdonBehaviour(newProxy, udonBehaviour);
try
{
UdonSharpEditorUtility.CopyUdonToProxy(newProxy);
}
catch (System.Exception e)
{
Debug.LogError(e);
}
if (shouldUndo)
{
Undo.DestroyObjectImmediate(targetObject);
}
else
{
Object.DestroyImmediate(targetObject);
}
newProxy.hideFlags = HideFlags.DontSaveInBuild |
#if !UDONSHARP_DEBUG
HideFlags.HideInInspector |
#endif
HideFlags.DontSaveInEditor;
newProxy.enabled = false;
}
finally
{
SetIgnoreEvents(false);
}
createdComponents.Add(udonBehaviour);
}
return(createdComponents.ToArray());
}
/// <summary>
/// Updates the selection due to a change to <see cref="SelectedIndex"/> or
/// <see cref="SelectedItem"/>.
/// </summary>
/// <param name="index">The new selected index.</param>
/// <param name="clear">Whether to clear existing selection.</param>
private void UpdateSelectedItem(int index, bool clear = true)
{
var oldIndex = _selectedIndex;
var oldItem = _selectedItem;
if (index == -1 && AlwaysSelected)
{
index = Math.Min(SelectedIndex, ItemCount - 1);
}
var item = ElementAt(Items, index);
var itemChanged = !Equals(item, oldItem);
var added = -1;
HashSet <int> removed = null;
_selectedIndex = index;
_selectedItem = item;
if (oldIndex != index || itemChanged || _selection.HasMultiple)
{
if (clear)
{
removed = _selection.Clear();
}
if (index != -1)
{
if (_selection.Add(index))
{
added = index;
}
if (removed?.Contains(index) == true)
{
removed.Remove(index);
added = -1;
}
}
if (removed != null)
{
foreach (var i in removed)
{
MarkItemSelected(i, false);
}
}
MarkItemSelected(index, true);
RaisePropertyChanged(
SelectedIndexProperty,
oldIndex,
index);
}
if (itemChanged)
{
RaisePropertyChanged(
SelectedItemProperty,
oldItem,
item);
}
if (removed != null && index != -1)
{
removed.Remove(index);
}
if (added != -1 || removed?.Count > 0)
{
ResetSelectedItems();
var e = new SelectionChangedEventArgs(
SelectionChangedEvent,
added != -1 ? new[] { ElementAt(Items, added) } : Array.Empty <object>(),
removed?.Select(x => ElementAt(Items, x)).ToArray() ?? Array.Empty <object>());
RaiseEvent(e);
}
if (AutoScrollToSelectedItem && _selectedIndex != -1)
{
ScrollIntoView(_selectedItem);
}
}
public static void AnalyzeResourcesAction()
{
var target = The.UI.GetActiveTarget();
requestedPaths = new List <PathRequestRecord>();
var crossRefReport = new List <Tuple <string, List <string> > >();
var missingResourcesReport = new List <string>();
var suspiciousTexturesReport = new List <string>();
var bundles = new HashSet <string>();
var cookingRulesMap = CookingRulesBuilder.Build(The.Workspace.AssetFiles, target);
AssetBundle.Current = new PackedAssetBundle(The.Workspace.GetBundlePath(target.Platform, CookingRulesBuilder.MainBundleName));
foreach (var i in cookingRulesMap)
{
if (i.Key.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
{
if (i.Value.TextureAtlas == null && i.Value.PVRFormat != PVRFormat.PVRTC4 && i.Value.PVRFormat != PVRFormat.PVRTC4_Forced)
{
suspiciousTexturesReport.Add(string.Format("{0}: {1}, atlas: none",
i.Key, i.Value.PVRFormat));
}
if (i.Value.PVRFormat != PVRFormat.PVRTC4 && i.Value.PVRFormat != PVRFormat.PVRTC4_Forced && i.Value.PVRFormat != PVRFormat.PVRTC2)
{
int w;
int h;
bool hasAlpha;
TextureConverterUtils.GetPngFileInfo(
Path.Combine(The.Workspace.AssetsDirectory, i.Key), out w, out h,
out hasAlpha, false);
if (w >= 1024 || h >= 1024)
{
suspiciousTexturesReport.Add(string.Format("{3}: {0}, {1}, {2}, {4}, atlas: {5}",
w, h, hasAlpha, i.Key, i.Value.PVRFormat, i.Value.TextureAtlas));
}
}
}
foreach (var bundle in i.Value.Bundles)
{
if (bundle != CookingRulesBuilder.MainBundleName)
{
bundles.Add(bundle);
}
}
}
AssetBundle.Current = new AggregateAssetBundle(bundles.Select(i => new PackedAssetBundle(The.Workspace.GetBundlePath(target.Platform, i))).ToArray());
The.Workspace.AssetFiles.EnumerationFilter = (info) => {
CookingRules rules;
if (cookingRulesMap.TryGetValue(info.Path, out rules))
{
if (rules.Ignore)
{
return(false);
}
}
return(true);
};
var usedImages = new HashSet <string>();
var usedSounds = new HashSet <string>();
foreach (var srcFileInfo in The.Workspace.AssetFiles.Enumerate(".tan"))
{
var srcPath = srcFileInfo.Path;
using (var scene = (Frame)Node.CreateFromAssetBundle(srcPath)) {
foreach (var j in scene.Descendants)
{
var checkTexture = new Action <SerializableTexture>((Lime.SerializableTexture t) => {
if (t == null)
{
return;
}
string texPath;
try {
texPath = t.SerializationPath;
} catch {
return;
}
if (string.IsNullOrEmpty(texPath))
{
return;
}
if (texPath.Length == 2 && texPath[0] == '#')
{
switch (texPath[1])
{
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
return;
default:
suspiciousTexturesReport.Add(string.Format("wrong render target: {0}, {1}", texPath, j.ToString()));
return;
}
}
string[] possiblePaths = new string[]
{
texPath + ".atlasPart",
texPath + ".pvr",
texPath + ".jpg",
texPath + ".png",
texPath + ".dds",
texPath + ".jpg",
texPath + ".png",
};
foreach (var tpp in possiblePaths)
{
if (Lime.AssetBundle.Current.FileExists(tpp))
{
Lime.AssetBundle.Current.OpenFile(tpp);
usedImages.Add(texPath.Replace('\\', '/'));
return;
}
}
missingResourcesReport.Add(string.Format("texture missing:\n\ttexture path: {0}\n\tscene path: {1}\n",
t.SerializationPath, j.ToString()));
});
var checkAnimators = new Action <Node>((Node n) => {
Lime.Animator <Lime.SerializableTexture> ta;
if (n.Animators.TryFind <SerializableTexture>("Texture", out ta))
{
foreach (var key in ta.ReadonlyKeys)
{
checkTexture(key.Value);
}
}
});
if (j is Widget)
{
var w = j as Lime.Widget;
var serializableTexture = w.Texture as SerializableTexture;
if (serializableTexture != null)
{
checkTexture(serializableTexture);
}
checkAnimators(w);
}
else if (j is ParticleModifier)
{
var pm = j as Lime.ParticleModifier;
var serializableTexture = pm.Texture as SerializableTexture;
if (serializableTexture != null)
{
checkTexture(serializableTexture);
}
checkAnimators(pm);
}
else if (j is Lime.Audio)
{
var au = j as Lime.Audio;
var path = au.Sample.SerializationPath + ".sound";
usedSounds.Add(au.Sample.SerializationPath.Replace('\\', '/'));
if (!Lime.AssetBundle.Current.FileExists(path))
{
missingResourcesReport.Add(string.Format("audio missing:\n\taudio path: {0}\n\tscene path: {1}\n",
path, j.ToString()));
}
else
{
using (var tempStream = Lime.AssetBundle.Current.OpenFile(path)) {
}
}
// FIXME: should we check for audio:Sample animators too?
}
}
}
var reportList = new List <string>();
foreach (var rpr in requestedPaths)
{
string pattern = String.Format(@".*[/\\](.*)\.{0}", target.Platform.ToString());
string bundle = "";
foreach (Match m in Regex.Matches(rpr.bundle, pattern, RegexOptions.IgnoreCase))
{
bundle = m.Groups[1].Value;
}
int index = Array.IndexOf(cookingRulesMap[srcPath].Bundles, bundle);
if (index == -1)
{
reportList.Add(string.Format("\t[{0}]=>[{2}]: {1}",
string.Join(", ", cookingRulesMap[srcPath].Bundles), rpr.path, bundle));
}
}
requestedPaths.Clear();
if (reportList.Count > 0)
{
crossRefReport.Add(new Tuple <string, List <string> >(srcPath, reportList));
}
Lime.Application.FreeScheduledActions();
}
var allImages = new Dictionary <string, bool>();
foreach (var img in The.Workspace.AssetFiles.Enumerate(".png"))
{
var key = Path.Combine(Path.GetDirectoryName(img.Path), Path.GetFileNameWithoutExtension(img.Path)).Replace('\\', '/');
if (!key.StartsWith("Fonts"))
{
allImages[key] = false;
}
}
foreach (var img in usedImages)
{
allImages[img] = true;
}
var unusedImages = allImages.Where(kv => !kv.Value).Select(kv => kv.Key).ToList();
var allSounds = new Dictionary <string, bool>();
foreach (var sound in The.Workspace.AssetFiles.Enumerate(".ogg"))
{
var key = Path.Combine(Path.GetDirectoryName(sound.Path), Path.GetFileNameWithoutExtension(sound.Path))
.Replace('\\', '/');
allSounds[key] = false;
}
foreach (var sound in usedSounds)
{
allSounds[sound] = true;
}
var unusedSounds = allSounds.Where(kv => !kv.Value).Select(kv => kv.Key).ToList();
Action <string> writeHeader = (s) => {
int n0 = (80 - s.Length) / 2;
int n1 = (80 - s.Length) % 2 == 0 ? n0 : n0 - 1;
Console.WriteLine("\n" + new String('=', n0) + " " + s + " " + new String('=', n1));
};
writeHeader("Cross Bundle Dependencies");
foreach (var scenePath in crossRefReport)
{
Console.WriteLine("\n" + scenePath.Item1);
foreach (var refStr in scenePath.Item2)
{
Console.WriteLine(refStr);
}
}
writeHeader("Missing Resources");
foreach (var s in missingResourcesReport)
{
Console.WriteLine(s);
}
writeHeader("Unused Images");
foreach (var s in unusedImages)
{
Console.WriteLine(s);
}
writeHeader("Unused Sounds");
foreach (var s in unusedSounds)
{
Console.WriteLine(s);
}
writeHeader("Suspicious Textures");
foreach (var s in suspiciousTexturesReport)
{
Console.WriteLine(s);
}
The.Workspace.AssetFiles.EnumerationFilter = null;
}
public void All_symbols_in_card_texts_are_considered_in_code()
{
var alphabet = new HashSet <char>();
var languages = new HashSet <string>(CardLocalization.GetAllLanguages(), Str.Comparer);
languages.Remove("cn");
languages.Remove("tw");
languages.Remove("jp");
languages.Remove("kr");
foreach (var set in Repo.SetsByCode.Values)
{
alphabet.UnionWith(set.Name);
alphabet.UnionWith(set.Code);
}
foreach (var card in Repo.Cards)
{
alphabet.UnionWithNullable(card.NameEn);
alphabet.UnionWithNullable(card.TypeEn);
alphabet.UnionWithNullable(card.FlavorEn);
alphabet.UnionWithNullable(card.TextEn);
alphabet.UnionWithNullable(card.Artist);
foreach (string lang in languages)
{
alphabet.UnionWithNullable(card.GetName(lang));
alphabet.UnionWithNullable(card.GetType(lang));
alphabet.UnionWithNullable(card.GetFlavor(lang));
alphabet.UnionWithNullable(card.GetText(lang));
}
}
var chars = alphabet.Select(c => char.ToLower(c, Str.Culture)).Distinct().OrderBy(c => c).ToArray();
Log.Debug(() => new string(chars));
var specialChars = new List <char>();
// ReSharper disable StringLiteralTypo
var latin = new HashSet <char>("abcdefghijklmnopqrstuvwxyz");
var cyrillic = new HashSet <char>("абвгдежзийклмнопрстуфхцчшщьыъэюя");
var numbers = new HashSet <char>("01234567890");
var knownSpecialChars = new HashSet <char>("ºß林泰玄");
// ReSharper restore StringLiteralTypo
foreach (char c in chars)
{
if (latin.Contains(c))
{
continue;
}
if (cyrillic.Contains(c))
{
continue;
}
if (numbers.Contains(c))
{
continue;
}
if (c == '\n')
{
continue;
}
if (c == '\r')
{
continue;
}
if (MtgAlphabet.Replacements.ContainsKey(c))
{
continue;
}
if (MtgAlphabet.WordCharsSet.Contains(c))
{
continue;
}
if (MtgAlphabet.LeftDelimitersSet.Contains(c))
{
continue;
}
if (MtgAlphabet.RightDelimitersSet.Contains(c))
{
continue;
}
if (MtgAlphabet.SingletoneWordChars.Contains(c))
{
continue;
}
if (knownSpecialChars.Contains(c))
{
continue;
}
specialChars.Add(c);
}
var specialCharsStr = new string(specialChars.ToArray());
Log.Debug(specialCharsStr);
var notConsideredChars = new string(specialCharsStr.Where(char.IsLetterOrDigit).ToArray());
Assert.That(notConsideredChars, Is.Empty);
}
internal async Task OnPersonaState(string nickname = null, string avatarHash = null)
{
if ((DateTime.UtcNow < LastAnnouncementCheck.AddHours(MinAnnouncementCheckTTL)) && (ShouldSendHeartBeats || (LastHeartBeat == DateTime.MinValue)))
{
return;
}
await RequestsSemaphore.WaitAsync().ConfigureAwait(false);
try {
if ((DateTime.UtcNow < LastAnnouncementCheck.AddHours(MinAnnouncementCheckTTL)) && (ShouldSendHeartBeats || (LastHeartBeat == DateTime.MinValue)))
{
return;
}
// Don't announce if we don't meet conditions
bool?eligible = await IsEligibleForMatching().ConfigureAwait(false);
if (!eligible.HasValue)
{
// This is actually network failure, so we'll stop sending heartbeats but not record it as valid check
ShouldSendHeartBeats = false;
return;
}
if (!eligible.Value)
{
LastAnnouncementCheck = DateTime.UtcNow;
ShouldSendHeartBeats = false;
return;
}
string tradeToken = await Bot.ArchiHandler.GetTradeToken().ConfigureAwait(false);
if (string.IsNullOrEmpty(tradeToken))
{
// This is actually network failure, so we'll stop sending heartbeats but not record it as valid check
ShouldSendHeartBeats = false;
return;
}
HashSet <Steam.Asset.EType> acceptedMatchableTypes = Bot.BotConfig.MatchableTypes.Where(type => AcceptedMatchableTypes.Contains(type)).ToHashSet();
if (acceptedMatchableTypes.Count == 0)
{
Bot.ArchiLogger.LogNullError(nameof(acceptedMatchableTypes));
LastAnnouncementCheck = DateTime.UtcNow;
ShouldSendHeartBeats = false;
return;
}
HashSet <Steam.Asset> inventory = await Bot.ArchiWebHandler.GetInventory(tradable : true, wantedTypes : acceptedMatchableTypes).ConfigureAwait(false);
if (inventory == null)
{
// This is actually inventory failure, so we'll stop sending heartbeats but not record it as valid check
ShouldSendHeartBeats = false;
return;
}
LastAnnouncementCheck = DateTime.UtcNow;
// This is actual inventory
if (inventory.Count < MinItemsCount)
{
ShouldSendHeartBeats = false;
return;
}
const string request = URL + "/Api/Announce";
Dictionary <string, string> data = new Dictionary <string, string>(9, StringComparer.Ordinal)
{
{ "AvatarHash", avatarHash ?? "" },
{ "GamesCount", inventory.Select(item => item.RealAppID).Distinct().Count().ToString() },
{ "Guid", ASF.GlobalDatabase.Guid.ToString("N") },
{ "ItemsCount", inventory.Count.ToString() },
{ "MatchableTypes", JsonConvert.SerializeObject(acceptedMatchableTypes) },
{ "MatchEverything", Bot.BotConfig.TradingPreferences.HasFlag(BotConfig.ETradingPreferences.MatchEverything) ? "1" : "0" },
{ "Nickname", nickname ?? "" },
{ "SteamID", Bot.SteamID.ToString() },
{ "TradeToken", tradeToken }
};
WebBrowser.BasicResponse response = await Bot.ArchiWebHandler.WebBrowser.UrlPost(request, data, requestOptions : WebBrowser.ERequestOptions.ReturnClientErrors).ConfigureAwait(false);
if (response == null)
{
return;
}
if (response.StatusCode.IsClientErrorCode())
{
LastHeartBeat = DateTime.MinValue;
ShouldSendHeartBeats = false;
return;
}
LastHeartBeat = DateTime.UtcNow;
ShouldSendHeartBeats = true;
} finally {
RequestsSemaphore.Release();
}
}
/// <inheritdoc />
public string DescribeExtent()
{
Contract.Assume(m_descriptors != null, "Init must have been called");
return(string.Join(", ", m_descriptors.Select(descriptor => descriptor.Name)));
}
public IDirectoryContents GetDirectoryContents(string subpath)
{
if (subpath == null)
{
return(NotFoundDirectoryContents.Singleton);
}
var folder = NormalizePath(subpath);
var entries = new List <IFileInfo>();
if (folder == "")
{
entries.Add(new EmbeddedDirectoryInfo(Application.ModulesPath));
}
else if (folder == Application.ModulesPath)
{
entries.AddRange(Application.ModuleNames
.Select(n => new EmbeddedDirectoryInfo(n)));
}
else if (folder == Application.ModulePath)
{
return(new PhysicalDirectoryContents(Application.Path));
}
else if (folder.StartsWith(Application.ModuleRoot, StringComparison.Ordinal))
{
var tokenizer = new StringTokenizer(folder, new char[] { '/' });
if (tokenizer.Any(s => s == "Pages" || s == "Views"))
{
var folderSubPath = folder.Substring(Application.ModuleRoot.Length);
return(new PhysicalDirectoryContents(Application.Root + folderSubPath));
}
}
else if (folder.StartsWith(Application.ModulesRoot, StringComparison.Ordinal))
{
var path = folder.Substring(Application.ModulesRoot.Length);
var index = path.IndexOf('/');
var name = index == -1 ? path : path.Substring(0, index);
var assetPaths = _environment.GetModule(name).AssetPaths;
var folders = new HashSet <string>(StringComparer.Ordinal);
var folderSlash = folder + '/';
foreach (var assetPath in assetPaths.Where(a => a.StartsWith(folderSlash, StringComparison.Ordinal)))
{
var folderPath = assetPath.Substring(folderSlash.Length);
var pathIndex = folderPath.IndexOf('/');
var isFilePath = pathIndex == -1;
if (isFilePath)
{
entries.Add(GetFileInfo(assetPath));
}
else
{
folders.Add(folderPath.Substring(0, pathIndex));
}
}
entries.AddRange(folders.Select(f => new EmbeddedDirectoryInfo(f)));
}
return(new EmbeddedDirectoryContents(entries));
}
Configuration.PackageReference[] GetWorkflowPackageDependencies(string[] fileNames)
{
var assemblies = new HashSet <Assembly>();
foreach (var path in fileNames)
{
var metadata = WorkflowBuilder.ReadMetadata(path);
using (var markupReader = new StringReader(metadata.WorkflowMarkup))
using (var reader = XmlReader.Create(markupReader))
{
reader.ReadToFollowing(WorkflowElementName);
using (var workflowReader = reader.ReadSubtree())
{
while (workflowReader.ReadToFollowing(ExpressionElementName))
{
if (!workflowReader.HasAttributes)
{
continue;
}
if (workflowReader.GetAttribute(TypeAttributeName, XsiAttributeValue) == IncludeWorkflowTypeName)
{
var includePath = workflowReader.GetAttribute(PathAttributeName);
var separatorIndex = includePath != null?includePath.IndexOf(AssemblySeparator) : -1;
if (separatorIndex >= 0 && !Path.IsPathRooted(includePath))
{
var assemblyName = includePath.Split(new[] { AssemblySeparator }, 2)[0];
if (!string.IsNullOrEmpty(assemblyName))
{
var assembly = Assembly.Load(assemblyName);
assemblies.Add(assembly);
}
}
}
}
}
}
assemblies.Add(typeof(WorkflowBuilder).Assembly);
assemblies.AddRange(metadata.GetExtensionTypes().Select(type => type.Assembly));
var layoutPath = Path.ChangeExtension(path, BonsaiExtension + LayoutExtension);
if (File.Exists(layoutPath))
{
var visualizerMap = new Lazy <IDictionary <string, Type> >(() =>
TypeVisualizerLoader.GetTypeVisualizerDictionary(packageConfiguration)
.Select(descriptor => descriptor.VisualizerTypeName).Distinct()
.Select(typeName => Type.GetType(typeName, false))
.Where(type => type != null)
.ToDictionary(type => type.FullName)
.Wait());
using (var reader = XmlReader.Create(layoutPath))
{
var layout = (VisualizerLayout)VisualizerLayout.Serializer.Deserialize(reader);
foreach (var settings in GetVisualizerSettings(layout))
{
Type type;
var typeName = settings.VisualizerTypeName;
if (typeName == null)
{
continue;
}
if (visualizerMap.Value.TryGetValue(typeName, out type))
{
assemblies.Add(type.Assembly);
}
}
}
}
}
var packageMap = GetPackageReferenceMap(packageConfiguration);
var dependencies = GetAssemblyPackageReferences(
packageConfiguration,
assemblies.Select(assembly => assembly.GetName().Name),
packageMap);
if (File.Exists(scriptEnvironment.ProjectFileName))
{
dependencies = dependencies.Concat(
from id in scriptEnvironment.GetPackageReferences()
where packageConfiguration.Packages.Contains(id)
select packageConfiguration.Packages[id]);
}
return(dependencies.ToArray());
}
static Weights()
{
try
{
_drawingTargets = new List <Targets.Item>();
Items = new HashSet <Item>
{
new Item(
"killable", "AA Killable", 20, false,
t => t.Health < ObjectManager.Player.GetAutoAttackDamage(t, true) ? 10 : 0),
new Item(
"attack-damage", "Attack Damage", 15, false, delegate(Obj_AI_Hero t)
{
var ad = t.FlatPhysicalDamageMod;
ad += ad / 100 * (t.Crit * 100) * (t.HasItem(ItemData.Infinity_Edge.Id) ? 2.5f : 2f);
var averageArmor = GameObjects.AllyHeroes.Select(a => a.Armor).DefaultIfEmpty(0).Average() *
t.PercentArmorPenetrationMod - t.FlatArmorPenetrationMod;
return((ad * (100 / (100 + (averageArmor > 0 ? averageArmor : 0)))) * t.AttackSpeedMod);
}),
new Item(
"ability-power", "Ability Power", 15, false, delegate(Obj_AI_Hero t)
{
var averageMr =
GameObjects.AllyHeroes.Select(a => a.SpellBlock).DefaultIfEmpty(0).Average() *
t.PercentMagicPenetrationMod - t.FlatMagicPenetrationMod;
return(t.FlatMagicDamageMod * (100 / (100 + (averageMr > 0 ? averageMr : 0))));
}),
new Item(
"low-resists", "Resists", 0, true,
t =>
ObjectManager.Player.FlatPhysicalDamageMod >= ObjectManager.Player.FlatMagicDamageMod
? t.Armor
: t.SpellBlock),
new Item("low-health", "Health", 20, true, t => t.Health),
new Item(
"short-distance-player", "Distance to Player", 5, true, t => t.Distance(ObjectManager.Player)),
new Item("short-distance-cursor", "Distance to Cursor", 0, true, t => t.Distance(Game.CursorPos)),
new Item(
"crowd-control", "Crowd Control", 0, false, delegate(Obj_AI_Hero t)
{
var buffs =
t.Buffs.Where(
x =>
x.Type == BuffType.Charm || x.Type == BuffType.Knockback ||
x.Type == BuffType.Suppression || x.Type == BuffType.Fear ||
x.Type == BuffType.Taunt || x.Type == BuffType.Stun || x.Type == BuffType.Slow ||
x.Type == BuffType.Silence || x.Type == BuffType.Snare ||
x.Type == BuffType.Polymorph).ToList();
return(buffs.Any() ? buffs.Max(x => x.EndTime) + 1f : 0f);
}),
new Item(
"gold", "Acquired Gold", 0, false,
t =>
(t.MinionsKilled + t.NeutralMinionsKilled) * 22.35f + t.ChampionsKilled * 300f +
t.Assists * 95f),
new Item(
"team-focus", "Team Focus", 0, false,
t =>
Aggro.Items.Where(a => a.Value.Target.Hero.NetworkId == t.NetworkId)
.Select(a => a.Value.Value)
.DefaultIfEmpty(0)
.Sum()),
new Item(
"focus-me", "Focus Me", 0, false, delegate(Obj_AI_Hero t)
{
var entry = Aggro.GetSenderTargetEntry(t, ObjectManager.Player);
return(entry != null ? entry.Value + 1f : 0);
})
};
Average = (float)Items.Select(w => w.Weight).DefaultIfEmpty(0).Average();
MaxRange = 2000f;
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <inheritdoc/>
protected override void ReParseImpl()
{
Stopwatch stopwatch = Stopwatch.StartNew();
ITextSnapshot snapshot = TextBuffer.CurrentSnapshot;
try
{
ITextDocument textDocument = TextDocument;
string fileName = textDocument != null ? textDocument.FilePath : null;
Document document = snapshot.GetOpenDocumentInCurrentContextWithChanges();
SourceTextContainer textContainer = document != null?document.GetTextAsync().Result.Container : null;
Project project = document != null ? document.Project : null;
Solution solution = project.Solution;
List <ITagSpan <IInheritanceTag> > tags = new List <ITagSpan <IInheritanceTag> >();
if (document != null && !string.IsNullOrEmpty(fileName))
{
SyntaxTree syntaxTree = document.GetSyntaxTreeAsync().Result;
SyntaxNode syntaxRoot = syntaxTree.GetRoot();
SemanticModel semanticModel = document.GetSemanticModelAsync().Result;
Compilation compilation = semanticModel.Compilation;
IDictionary <ISymbol, ISet <ISymbol> > interfaceImplementations = new Dictionary <ISymbol, ISet <ISymbol> >();
List <CSharpSyntaxNode> allMembers = new List <CSharpSyntaxNode>();
IEnumerable <BaseTypeDeclarationSyntax> typeNodes = syntaxRoot.DescendantNodes().OfType <BaseTypeDeclarationSyntax>();
foreach (var typeNode in typeNodes)
{
ISymbol symbol = semanticModel.GetDeclaredSymbol(typeNode);
if (symbol == null)
{
MarkDirty(true);
return;
}
INamedTypeSymbol typeSymbol = symbol as INamedTypeSymbol;
if (typeSymbol == null)
{
continue;
}
// get implemented interface symbols
foreach (INamedTypeSymbol namedTypeSymbol in typeSymbol.AllInterfaces)
{
foreach (ISymbol member in namedTypeSymbol.GetMembers())
{
ISymbol implementation = typeSymbol.FindImplementationForInterfaceMember(member);
if (implementation == null || !implementation.ContainingSymbol.Equals(typeSymbol))
{
continue;
}
ISet <ISymbol> symbols;
if (!interfaceImplementations.TryGetValue(implementation, out symbols))
{
symbols = new HashSet <ISymbol>();
interfaceImplementations[implementation] = symbols;
}
symbols.Add(member);
}
}
TypeDeclarationSyntax typeDeclarationSyntax = typeNode as TypeDeclarationSyntax;
if (typeDeclarationSyntax != null)
{
allMembers.AddRange(typeDeclarationSyntax.Members);
}
if (typeSymbol.IsSealed)
{
continue;
}
// types which implement or derive from this type
ISet <ITypeSymbol> derivedTypes = new HashSet <ITypeSymbol>();
derivedTypes.UnionWith(FindDerivedClassesAsync.Value(typeSymbol, solution, null, CancellationToken.None).Result);
derivedTypes.UnionWith(FindDerivedInterfacesAsync.Value(typeSymbol, solution, null, CancellationToken.None).Result);
derivedTypes.UnionWith(FindImplementingTypesAsync.Value(typeSymbol, solution, null, CancellationToken.None).Result);
if (derivedTypes.Count == 0)
{
continue;
}
StringBuilder builder = new StringBuilder();
string elementKindDisplayName =
"types";
builder.AppendLine("Derived " + elementKindDisplayName + ":");
foreach (var derived in derivedTypes)
{
builder.AppendLine(" " + derived.ToString());
}
SyntaxToken identifier = typeNode.Accept(IdentifierSyntaxVisitor.Instance);
SnapshotSpan span = new SnapshotSpan(snapshot, new Span(identifier.SpanStart, identifier.Span.Length));
InheritanceGlyph tag = typeSymbol.TypeKind == TypeKind.Interface ? InheritanceGlyph.HasImplementations : InheritanceGlyph.Overridden;
var targets = derivedTypes.Select(i => new TypeTarget(textContainer, i, solution));
tags.Add(new TagSpan <IInheritanceTag>(span, _tagFactory.CreateTag(tag, builder.ToString().TrimEnd(), targets)));
}
foreach (var eventFieldDeclarationSyntax in allMembers.OfType <EventFieldDeclarationSyntax>().ToArray())
{
allMembers.AddRange(eventFieldDeclarationSyntax.Declaration.Variables);
}
foreach (CSharpSyntaxNode memberNode in allMembers)
{
if (!(memberNode is MethodDeclarationSyntax) &&
!(memberNode is PropertyDeclarationSyntax) &&
!(memberNode is EventDeclarationSyntax) &&
!(memberNode is VariableDeclaratorSyntax))
{
continue;
}
ISymbol symbol = semanticModel.GetDeclaredSymbol(memberNode);
if (symbol == null)
{
MarkDirty(true);
return;
}
// members which this member implements
ISet <ISymbol> implementedMethods = new HashSet <ISymbol>();
if (!interfaceImplementations.TryGetValue(symbol, out implementedMethods))
{
implementedMethods = new HashSet <ISymbol>();
}
ISet <ISymbol> overriddenMethods = new HashSet <ISymbol>();
IMethodSymbol methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
// methods which this method overrides
for (IMethodSymbol current = methodSymbol.OverriddenMethod;
current != null;
current = current.OverriddenMethod)
{
overriddenMethods.Add(current);
}
}
else
{
IPropertySymbol propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
// properties which this property overrides
for (IPropertySymbol current = propertySymbol.OverriddenProperty;
current != null;
current = current.OverriddenProperty)
{
overriddenMethods.Add(current);
}
}
else
{
IEventSymbol eventSymbol = symbol as IEventSymbol;
if (eventSymbol != null)
{
// events which this event overrides
for (IEventSymbol current = eventSymbol.OverriddenEvent;
current != null;
current = current.OverriddenEvent)
{
overriddenMethods.Add(current);
}
}
}
}
ISet <ISymbol> implementingMethods = new HashSet <ISymbol>(SymbolFinder.FindImplementationsAsync(symbol, solution).Result);
ISet <ISymbol> overridingMethods = new HashSet <ISymbol>(SymbolFinder.FindOverridesAsync(symbol, solution).Result);
if (implementingMethods.Count == 0 && implementedMethods.Count == 0 && overriddenMethods.Count == 0 && overridingMethods.Count == 0)
{
continue;
}
StringBuilder builder = new StringBuilder();
string elementKindDisplayName =
symbol is IPropertySymbol ? "properties" :
symbol is IEventSymbol ? "events" :
"methods";
if (implementedMethods.Count > 0)
{
builder.AppendLine("Implemented " + elementKindDisplayName + ":");
foreach (var methodId in implementedMethods)
{
builder.AppendLine(" " + methodId.ToString());
}
}
if (overriddenMethods.Count > 0)
{
builder.AppendLine("Overridden " + elementKindDisplayName + ":");
foreach (var methodId in overriddenMethods)
{
builder.AppendLine(" " + methodId.ToString());
}
}
if (implementingMethods.Count > 0)
{
builder.AppendLine("Implementing " + elementKindDisplayName + " in derived types:");
foreach (var methodId in implementingMethods)
{
builder.AppendLine(" " + methodId.ToString());
}
}
if (overridingMethods.Count > 0)
{
builder.AppendLine("Overriding " + elementKindDisplayName + " in derived types:");
foreach (var methodId in overridingMethods)
{
builder.AppendLine(" " + methodId.ToString());
}
}
SyntaxToken identifier = memberNode.Accept(IdentifierSyntaxVisitor.Instance);
SnapshotSpan span = new SnapshotSpan(snapshot, new Span(identifier.SpanStart, identifier.Span.Length));
InheritanceGlyph tag;
if (implementedMethods.Count > 0)
{
if (overridingMethods.Count > 0)
{
tag = InheritanceGlyph.ImplementsAndOverridden;
}
else if (implementingMethods.Count > 0)
{
tag = InheritanceGlyph.ImplementsAndHasImplementations;
}
else
{
tag = InheritanceGlyph.Implements;
}
}
else if (implementingMethods.Count > 0)
{
tag = InheritanceGlyph.HasImplementations;
}
else if (overriddenMethods.Count > 0)
{
if (overridingMethods.Count > 0)
{
tag = InheritanceGlyph.OverridesAndOverridden;
}
else
{
tag = InheritanceGlyph.Overrides;
}
}
else
{
tag = InheritanceGlyph.Overridden;
}
List <ISymbol> members = new List <ISymbol>();
members.AddRange(implementedMethods);
members.AddRange(overriddenMethods);
members.AddRange(implementingMethods);
members.AddRange(overridingMethods);
var targets = members.Select(i => new MemberTarget(textContainer, i, solution));
tags.Add(new TagSpan <IInheritanceTag>(span, _tagFactory.CreateTag(tag, builder.ToString().TrimEnd(), targets)));
}
}
InheritanceParseResultEventArgs result = new InheritanceParseResultEventArgs(snapshot, stopwatch.Elapsed, tags);
OnParseComplete(result);
}
catch (InvalidOperationException)
{
MarkDirty(true);
throw;
}
}
private bool DPLLAlgo(CNF f, List <int> unchLit, Dictionary <int, int> totalModel)
{
//Console.WriteLine(f);
CNF newf = f;
do
{
if (newf.IsEmpty())
{
model = new Dictionary <int, int>(totalModel);
return(true);
}
if (newf.HasEmptyConj())
{
return(false);
}
var unionLit = newf.GetUnionDisj();
HashSet <Literal> newLit = new HashSet <Literal>();
foreach (var u in unionLit)
{
UnitPropagation(u, totalModel, newLit);
}
unchLit.RemoveAll(x => newLit.Select(y => y.Name).Contains(x));
newf = EliminatePureLiterals(newf, newLit);
} while (newf.GetUnionDisj().Count > 0);
if (newf.IsEmpty())
{
model = new Dictionary <int, int>(totalModel);
return(true);
}
if (newf.HasEmptyConj())
{
return(false);
}
var l = ChooseLiteral(unchLit);
if (l.Name == 0) // нет невыьранных литералов
{
Console.WriteLine("no Lit: " + newf.Count);
return(DPLLAlgo(newf, unchLit, totalModel));
}
else
{
newf.Add(l);
if (DPLLAlgo(newf, new List <int>(unchLit), new Dictionary <int, int>(totalModel)))
{
return(true);
}
else
{
//Console.WriteLine("Back Track: " + l + " " + newf.Count + " UncLit:" + unchLit.Count);
newf.AddInversed(l);
return(DPLLAlgo(newf, unchLit, totalModel));
}
}
}
private List <ResolvedItem> ResolveItem(IdentifiableObject item,
ComponentTemplate template, HashSet <IdentifiableObject> resolved, int recurseLevel)
{
List <ResolvedItem> toResolve = new List <ResolvedItem>();
if (!ContinueRecursion(recurseLevel))
{
_log.Debug($"Reached max recusion level when trying to resolve item {item.Id}, skipping.");
return(toResolve);
}
List <Component> components = new List <Component>();
if (item is Page)
{
var page = (Page)item;
if (resolved.Contains(page))
{
return(toResolve);
}
components.AddRange(page.ComponentPresentations.Select(cp => cp.Component));
}
if (item is Component)
{
components.Add(item as Component);
}
if (components.Count <= 0)
{
return(toResolve);
}
var toProcess = new HashSet <Component>();
var depths = new Dictionary <Component, int>();
for (int i = 0; i < components.Count; i++)
{ // note: avoiding recursive approach here so we can truely do infinite depth without stack overflows
var c = components[i];
int depth = recurseLevel;
if (depths.ContainsKey(c))
{
depth = depths[c];
}
if (!ContinueRecursion(depth))
{
continue;
}
if (toProcess.Contains(c))
{
continue;
}
toProcess.Add(c);
List <Component> linked = GatherLinkedComponents(c);
foreach (var linkedComponent in linked)
{
if (!ContinueRecursion(depth + 1))
{
break;
}
if (toProcess.Contains(linkedComponent))
{
continue;
}
components.Add(linkedComponent);
depths.Add(linkedComponent, depth + 1);
}
}
toResolve.AddRange(toProcess.Select(
component => ResolveComponent(component, template, resolved, recurseLevel)).Where(r => r != null));
return(toResolve);
}
// Internal for testing
// metadataPropertyKeys.Key = property name, metadataPropertyKeys.Value = property type
internal static string Parse(string code, IEnumerable <KeyValuePair <string, string> > metadataPropertyKeys, IExecutionState executionState)
{
// Generate a syntax tree from the code
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(kind: SourceCodeKind.Script), cancellationToken: executionState.CancellationToken);
// "Lift" class and method declarations
LiftingWalker liftingWalker = new LiftingWalker();
liftingWalker.Visit(syntaxTree.GetRoot(executionState.CancellationToken));
// Get the using statements
HashSet <string> namespaces = new HashSet <string>(executionState.Namespaces);
namespaces.Add("System");
namespaces.Add("System.Collections");
namespaces.Add("System.Collections.Generic");
namespaces.Add("System.Linq");
namespaces.Add("System.Text");
namespaces.Add("Statiq.Core");
string usingStatements = string.Join(Environment.NewLine, namespaces.Select(x => "using " + x + ";"));
// Get the document metadata properties and add to the script host object,
// but only if they don't conflict with properties from ScriptBase
string metadataProperties =
metadataPropertyKeys == null
? string.Empty
: string.Join(
Environment.NewLine,
metadataPropertyKeys
.Where(x => !string.IsNullOrWhiteSpace(x.Key) && !ReservedPropertyNames.Contains(x.Key))
.Select(x => $"public {x.Value ?? "object"} {GetValidIdentifier(x.Key)} => Metadata.Get<{x.Value ?? "object"}>(\"{x.Key}\");"));
// Determine if we need a return statement
string preScript = null;
string postScript = null;
if (!code.Contains(';'))
{
// This is an expression, so add the return before and semicolon after
preScript = "return";
postScript = ";";
}
else if (!liftingWalker.HasReturnStatement)
{
// Includes multiple statements but no return so add one
postScript = "return null;";
}
// Get call signatures for IExecutionState and IMetadata
string executionStateCalls = string.Join(
Environment.NewLine,
ReflectionHelper.GetCallSignatures(typeof(IExecutionState), nameof(ScriptBase.ExecutionState)));
string metadataCalls = string.Join(
Environment.NewLine,
ReflectionHelper.GetCallSignatures(typeof(IMetadata), nameof(ScriptBase.Metadata)));
// Return the fully parsed script
return
($@"{usingStatements}
{liftingWalker.UsingDirectives}
public class {ScriptClassName} : ScriptBase, IExecutionState, IMetadata
{{
public {ScriptClassName}(IMetadata metadata, IExecutionState executionState, IExecutionContext executionContext)
: base(metadata, executionState, executionContext) {{ }}
public override async Task<object> EvaluateAsync()
{{
await Task.CompletedTask;
{preScript}
{liftingWalker.ScriptCode}
{postScript}
}}
{liftingWalker.MethodDeclarations}
{metadataProperties}
{executionStateCalls}
{metadataCalls}
}}
{liftingWalker.TypeDeclarations}
public static class ScriptExtensionMethods
{{
{liftingWalker.ExtensionMethodDeclarations}
}}");
}
private static ReferenceInfo?BuildReference(
ProjectAssetsFile projectAssets,
string referenceName,
bool treatAsUsed)
{
var dependencyNames = new HashSet <string>();
var compilationAssemblies = ImmutableArray.CreateBuilder <string>();
var referenceType = ReferenceType.Unknown;
var itemSpecification = referenceName;
var packagesPath = projectAssets.Project?.Restore?.PackagesPath ?? string.Empty;
RoslynDebug.AssertNotNull(projectAssets.Targets);
RoslynDebug.AssertNotNull(projectAssets.Libraries);
foreach (var target in projectAssets.Targets.Values)
{
var key = target.Keys.FirstOrDefault(library => library.Split('/')[0] == referenceName);
if (key is null ||
!projectAssets.Libraries.TryGetValue(key, out var library))
{
continue;
}
var targetLibrary = target[key];
referenceType = targetLibrary.Type switch
{
"package" => ReferenceType.Package,
"project" => ReferenceType.Project,
_ => ReferenceType.Assembly
};
if (referenceType == ReferenceType.Project &&
library.Path is not null)
{
// Project references are keyed by their filename but the
// item specification should be the path to the project file
// with Windows-style directory separators.
itemSpecification = library.Path.Replace('/', '\\');
}
if (targetLibrary.Dependencies != null)
{
dependencyNames.AddRange(targetLibrary.Dependencies.Keys);
}
if (targetLibrary.Compile != null)
{
compilationAssemblies.AddRange(targetLibrary.Compile.Keys
.Where(assemblyPath => !assemblyPath.EndsWith(NuGetEmptyFileName))
.Select(assemblyPath => Path.GetFullPath(Path.Combine(packagesPath, library.Path, assemblyPath))));
}
}
if (referenceType == ReferenceType.Unknown)
{
return(null);
}
var dependencies = dependencyNames
.Select(dependency => BuildReference(projectAssets, dependency, treatAsUsed: false))
.WhereNotNull()
.ToImmutableArray();
return(new ReferenceInfo(referenceType, itemSpecification, treatAsUsed, compilationAssemblies.ToImmutable(), dependencies));
}
}
public Tuple <HashSet <int>, HashSet <int> > LargestCliqueHeuristic(bool modeVerticesOnly)
{
var path = @"C:\Users\User\Documents\log.txt";
var vertexDegrees = VertexDegrees();
var list = new LinkedList <CliqueNode>();
var queue = new FastPriorityQueue <CliqueNode>(Size);
for (var i = 0; i < vertexDegrees.Length; i++)
{
var cliqueNode = new CliqueNode(i, vertexDegrees[i]);
list.AddLast(cliqueNode);
queue.Enqueue(cliqueNode, cliqueNode.VertexSmallestDegree);
}
var unmergable = new bool[Size, Size];
var flag = true;
while (true)
{
CliqueNode node1 = queue.Dequeue(), node2 = null;
var unmergableWithNode1 = new LinkedList <CliqueNode>();
do
{
if (node2 != null)
{
unmergableWithNode1.AddLast(node2);
}
if (queue.Count <= 0)
{
// node1 is no more mergable with any of the elements in the queue
foreach (var node in unmergableWithNode1)
{
queue.Enqueue(node, node.VertexSmallestDegree);
}
unmergableWithNode1.Clear();
if (queue.Count <= 1)
{
flag = false;
break;
}
node1 = queue.Dequeue();
}
node2 = queue.Dequeue();
} while (unmergable[node1.CliqueNumber, node2.CliqueNumber]);
if (!flag)
{
break;
}
foreach (var node in unmergableWithNode1)
{
queue.Enqueue(node, node.VertexSmallestDegree);
}
var mergable = true;
foreach (var node1Vertex in node1.Vertices)
{
foreach (var node2Vertex in node2.Vertices)
{
if (!this.IsEdge(node1Vertex, node2Vertex))
{
queue.Enqueue(node1, node1.VertexSmallestDegree);
queue.Enqueue(node2, node2.VertexSmallestDegree);
unmergable[node1.CliqueNumber, node2.CliqueNumber] =
unmergable[node2.CliqueNumber, node1.CliqueNumber] = true;
mergable = false;
break;
}
}
if (!mergable)
{
break;
}
}
if (mergable)
{
using (var sw = File.AppendText(path))
{
sw.WriteLine($"{node1.CliqueNumber}-{node2.CliqueNumber}");
}
node1.Vertices.UnionWith(node2.Vertices);
node1.VertexSmallestDegree = Math.Min(node1.VertexSmallestDegree, node2.VertexSmallestDegree);
for (var i = 0; i < Size; i++)
{
unmergable[node1.CliqueNumber, i] |= unmergable[node2.CliqueNumber, i];
}
queue.Enqueue(node1, node1.VertexSmallestDegree);
}
}
HashSet <int> clique = null;
if (modeVerticesOnly)
{
foreach (var cliqueNode in list)
{
if (clique == null || cliqueNode.Vertices.Count > clique.Count)
{
clique = cliqueNode.Vertices;
}
}
}
else
{
var gEdgeCount = 0;
foreach (var cliqueNode in list)
{
if (clique == null)
{
clique = cliqueNode.Vertices;
}
else
{
var newGVertices = new HashSet <int>(cliqueNode.Vertices.Select(FirstGraphVertex));
var newGEdgeCount = _g.Subgraph(newGVertices).EdgeCount;
if (newGVertices.Count + newGEdgeCount > clique.Count + gEdgeCount)
{
clique = cliqueNode.Vertices;
gEdgeCount = newGEdgeCount;
}
}
}
}
var gVertices = new HashSet <int>(clique?.Select(FirstGraphVertex));
var hVertices = new HashSet <int>(clique?.Select(SecondGraphVertex));
return(new Tuple <HashSet <int>, HashSet <int> >(gVertices, hVertices));
}
/// <summary>
/// Fills in the set Jira sprint issues according to the defined rules.
/// </summary>
public async Task PrioritizeBacklogAsync()
{
// Retrieves the issues in the sprint asynchroniously.
Task <JiraSeachResults> getBacklogIssues = GetUnclosedSprintIssuesAsync();
// Awaits for retrieving the sprint issues.
JiraSeachResults backlogIssues = await getBacklogIssues;
if (backlogIssues == null)
{
Writer.WriteLine($"There are no issues in sprint {SprintId}.");
MailSender.SendMail(EmailFrom, EmailTo, EmailFromPassword, "CTC prioritization feels kinda weird", $"The tool hasn't found any issue in the given sprint (ID: {SprintId}). Is this really the sprint you want to prioritize?");
return;
}
Writer.WriteLine($"There are {backlogIssues.Count} issues to prioritize in sprint {SprintId}.");
Writer.WriteLine();
// Gets a non-duplicated list of epics
HashSet <string> epicKeys = new HashSet <string>();
foreach (JiraIssue issue in backlogIssues.Results)
{
if (issue.Fields.Epic != null && issue.Fields.Epic.StartsWith("CTC-"))
{
epicKeys.Add(issue.Fields.Epic);
}
}
// Retrieves the issues' epics asynchronously.
var epicIssues = epicKeys.Select(epic => GetEpic(epic)).ToList();
// Waits for the tasks creating pages and count their successfulness.
JiraIssue[] epics = await Task.WhenAll(epicIssues);
// Prioritizes the issues asynchronously.
var prioritizedIssues = backlogIssues.Results.Select(issue => ProcessIssueAsync(issue, issue.Fields.Epic != null && issue.Fields.Epic.StartsWith("CTC-") ? epics.Where(epic => epic.Key == issue.Fields.Epic).FirstOrDefault() : null)).ToList();
// Waits for the tasks creating pages and count their successfulness.
Tuple <int, string>[] prioritizedResults = await Task.WhenAll(prioritizedIssues);
/*
* // For debugging async-await
* List<String> prioritizedIssues = new List<string>();
* foreach (JiraIssue issue in backlogIssues.Results)
* {
* prioritizedIssues.Add(await ProcessIssueAsync(issue));
* }
* string[] prioritizedResults = prioritizedIssues.ToArray();
*/
// Write out the final results.
int failedIssueNumber = prioritizedResults.Where(x => x.Item1 == 0).Count();
Writer.WriteLine();
Writer.WriteLine("------------------------");
Writer.WriteLine("FINAL RESULTS");
Writer.WriteLine($"Number of all issues: {backlogIssues.Count}");
Writer.WriteLine();
Writer.WriteLine($"Number of updated issues: {prioritizedResults.Where(x => x.Item1 == 1).Count()}");
Writer.WriteLine($"Number of issues that didn't need to be updated: {prioritizedResults.Where(x => x.Item1 == 2).Count()}");
Writer.WriteLine($"Number of issues whose update failed: {failedIssueNumber}");
// If there were any failures, they are listed and a notification email is sent.
if (failedIssueNumber > 0)
{
StringBuilder failedIssues = new StringBuilder();
foreach (Tuple <int, string> t in prioritizedResults)
{
if (t.Item1 == 0)
{
failedIssues.AppendLine(t.Item2);
failedIssues.AppendLine();
}
}
Writer.WriteLine("");
Writer.WriteLine("Issues whose update failed:");
Writer.WriteLine(failedIssues.ToString());
MailSender.SendMail(EmailFrom, EmailTo, EmailFromPassword, "CTC prioritization ended with errors", $"Prioritization ended with the following errors in updates: {failedIssues.ToString()}");
}
}
public void Synchronize()
{
Task.Run(async() =>
{
try
{
if (Interlocked.Read(ref _runner) >= 2)
{
return;
}
Interlocked.Increment(ref _runner);
while (Interlocked.Read(ref _runner) != 1)
{
await Task.Delay(100);
}
if (Interlocked.Read(ref _running) >= 2)
{
return;
}
try
{
Interlocked.Exchange(ref _running, 1);
var isImmature = false; // The last 100 blocks are reorgable. (Assume it is mature at first.)
SyncInfo syncInfo = null;
while (IsRunning)
{
try
{
// If we didn't yet initialized syncInfo, do so.
if (syncInfo is null)
{
syncInfo = await GetSyncInfoAsync();
}
Height heightToRequest = StartingHeight;
uint256 currentHash = null;
using (await IndexLock.LockAsync())
{
if (Index.Count != 0)
{
var lastIndex = Index.Last();
heightToRequest = lastIndex.BlockHeight + 1;
currentHash = lastIndex.BlockHash;
}
}
// If not synchronized or already 5 min passed since last update, get the latest blockchain info.
if (!syncInfo.IsCoreSynchornized || (syncInfo.BlockchainInfoUpdated - DateTimeOffset.UtcNow) > TimeSpan.FromMinutes(5))
{
syncInfo = await GetSyncInfoAsync();
}
if (syncInfo.BlockCount - heightToRequest <= 100)
{
// Both Wasabi and our Core node is in sync. Start doing stuff through P2P from now on.
if (syncInfo.IsCoreSynchornized && syncInfo.BlockCount == heightToRequest - 1)
{
syncInfo = await GetSyncInfoAsync();
// Double it to make sure not to accidentally miss any notification.
if (syncInfo.IsCoreSynchornized && syncInfo.BlockCount == heightToRequest - 1)
{
// Mark the process notstarted, so it can be started again and finally block can mark it is stopped.
Interlocked.Exchange(ref _running, 0);
return;
}
}
// Mark the synchronizing process is working with immature blocks from now on.
isImmature = true;
}
Block block = await RpcClient.GetBlockAsync(heightToRequest);
// Reorg check, except if we're requesting the starting height, because then the "currentHash" wouldn't exist.
if (heightToRequest != StartingHeight && currentHash != block.Header.HashPrevBlock)
{
// Reorg can happen only when immature. (If it'd not be immature, that'd be a huge issue.)
if (isImmature)
{
await ReorgOneAsync();
}
else
{
Logger.LogCritical <IndexBuilderService>("This is something serious! Over 100 block reorg is noticed! We cannot handle that!");
}
// Skip the current block.
continue;
}
if (isImmature)
{
PrepareBech32UtxoSetHistory();
}
var scripts = new HashSet <Script>();
foreach (var tx in block.Transactions)
{
// If stop was requested return.
// Because this tx iteration can take even minutes
// It doesn't need to be accessed with a thread safe fasion with Interlocked through IsRunning, this may have some performance benefit
if (_running != 1)
{
return;
}
for (int i = 0; i < tx.Outputs.Count; i++)
{
var output = tx.Outputs[i];
if (!output.ScriptPubKey.IsPayToScriptHash && output.ScriptPubKey.IsWitness)
{
var outpoint = new OutPoint(tx.GetHash(), i);
Bech32UtxoSet.Add(outpoint, output.ScriptPubKey);
if (isImmature)
{
Bech32UtxoSetHistory.Last().StoreAction(ActionHistoryHelper.Operation.Add, outpoint, output.ScriptPubKey);
}
scripts.Add(output.ScriptPubKey);
}
}
foreach (var input in tx.Inputs)
{
OutPoint prevOut = input.PrevOut;
if (Bech32UtxoSet.TryGetValue(prevOut, out Script foundScript))
{
Bech32UtxoSet.Remove(prevOut);
if (isImmature)
{
Bech32UtxoSetHistory.Last().StoreAction(ActionHistoryHelper.Operation.Remove, prevOut, foundScript);
}
scripts.Add(foundScript);
}
}
}
GolombRiceFilter filter = null;
if (scripts.Count != 0)
{
filter = new GolombRiceFilterBuilder()
.SetKey(block.GetHash())
.SetP(20)
.SetM(1 << 20)
.AddEntries(scripts.Select(x => x.ToCompressedBytes()))
.Build();
}
var filterModel = new FilterModel
{
BlockHash = block.GetHash(),
BlockHeight = heightToRequest,
Filter = filter
};
await File.AppendAllLinesAsync(IndexFilePath, new[] { filterModel.ToHeightlessLine() });
using (await IndexLock.LockAsync())
{
Index.Add(filterModel);
}
if (File.Exists(Bech32UtxoSetFilePath))
{
File.Delete(Bech32UtxoSetFilePath);
}
await File.WriteAllLinesAsync(Bech32UtxoSetFilePath, Bech32UtxoSet
.Select(entry => entry.Key.Hash + ":" + entry.Key.N + ":" + ByteHelpers.ToHex(entry.Value.ToCompressedBytes())));
// If not close to the tip, just log debug.
// Use height.Value instead of simply height, because it cannot be negative height.
if (syncInfo.BlockCount - heightToRequest.Value <= 3 || heightToRequest % 100 == 0)
{
Logger.LogInfo <IndexBuilderService>($"Created filter for block: {heightToRequest}.");
}
else
{
Logger.LogDebug <IndexBuilderService>($"Created filter for block: {heightToRequest}.");
}
}
catch (Exception ex)
{
Logger.LogDebug <IndexBuilderService>(ex);
}
}
}
finally
{
Interlocked.CompareExchange(ref _running, 3, 2); // If IsStopping, make it stopped.
Interlocked.Decrement(ref _runner);
}
}
catch (Exception ex)
{
Logger.LogError <IndexBuilderService>($"Synchronization attempt failed to start: {ex}");
}
});
}
/// <summary>
/// This function returns a changeset based on the selections of the user.
/// Currently returns null if a conflict is detected.
/// </summary>
/// <param name="registry"></param>
/// <param name="changeSet"></param>
/// <param name="installer">A module installer for the current KSP install</param>
/// <param name="version">The version of the current KSP install</param>
public IEnumerable <ModChange> ComputeChangeSetFromModList(
IRegistryQuerier registry, HashSet <ModChange> changeSet, ModuleInstaller installer,
KspVersionCriteria version)
{
var modules_to_install = new HashSet <CkanModule>();
var modules_to_remove = new HashSet <CkanModule>();
foreach (var change in changeSet)
{
switch (change.ChangeType)
{
case GUIModChangeType.None:
break;
case GUIModChangeType.Update:
case GUIModChangeType.Install:
modules_to_install.Add(change.Mod);
break;
case GUIModChangeType.Remove:
modules_to_remove.Add(change.Mod);
break;
case GUIModChangeType.Replace:
ModuleReplacement repl = registry.GetReplacement(change.Mod, version);
if (repl != null)
{
modules_to_remove.Add(repl.ToReplace);
modules_to_install.Add(repl.ReplaceWith);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var installed_modules =
registry.InstalledModules.Select(imod => imod.Module).ToDictionary(mod => mod.identifier, mod => mod);
foreach (var dependency in registry.FindReverseDependencies(
modules_to_remove
.Select(mod => mod.identifier)
.Except(modules_to_install.Select(m => m.identifier))
))
{
//TODO This would be a good place to have an event that alters the row's graphics to show it will be removed
CkanModule depMod;
if (installed_modules.TryGetValue(dependency, out depMod))
{
CkanModule module_by_version = registry.GetModuleByVersion(depMod.identifier,
depMod.version)
?? registry.InstalledModule(dependency).Module;
changeSet.Add(new ModChange(module_by_version, GUIModChangeType.Remove, null));
modules_to_remove.Add(module_by_version);
}
}
foreach (var im in registry.FindRemovableAutoInstalled(
registry.InstalledModules.Where(im => !modules_to_remove.Any(m => m.identifier == im.identifier) || modules_to_install.Any(m => m.identifier == im.identifier))
))
{
changeSet.Add(new ModChange(im.Module, GUIModChangeType.Remove, new SelectionReason.NoLongerUsed()));
modules_to_remove.Add(im.Module);
}
// Get as many dependencies as we can, but leave decisions and prompts for installation time
RelationshipResolverOptions opts = RelationshipResolver.DependsOnlyOpts();
opts.without_toomanyprovides_kraken = true;
opts.without_enforce_consistency = true;
var resolver = new RelationshipResolver(
modules_to_install,
modules_to_remove,
opts, registry, version);
changeSet.UnionWith(
resolver.ModList()
.Select(m => new ModChange(m, GUIModChangeType.Install, resolver.ReasonFor(m))));
return(changeSet);
}
public void OnProductListFetched(AssetStorePurchases purchases, bool fetchDetailsCalled)
{
var isSet = purchases.queryArgs?.isFilterSet == true;
if (isSet && !filters.Equals(purchases.queryArgs))
{
return;
}
if (purchases.startIndex > 0 && numTotalItems != purchases.total)
{
// if a new page has arrived but the total has changed or the searchText has changed, do a re-fetch
var queryArgs = BuildQueryFromFilter((int)numCurrentItems, purchases.startIndex + purchases.list.Count);
m_AssetStoreClient.ListPurchases(queryArgs);
return;
}
var oldPackageIds = new HashSet <string>(m_VisualStateList.Select(v => v.packageUniqueId));
var newPackageIds = purchases.productIds.Select(id => id.ToString()).ToList();
if (purchases.startIndex == 0)
{
// override the result if the new list starts from index 0 (meaning it's a refresh)
m_VisualStateList.Rebuild(newPackageIds);
m_VisualStateList.ClearExtraItems();
m_VisualStateList.SetTotal(purchases.total);
}
else if (purchases.startIndex == numCurrentItems)
{
// append the result if it is the next page
m_VisualStateList.AddRange(newPackageIds);
m_VisualStateList.ClearExtraItems();
}
else
{
// if the content is neither starting from zero or next page, we simply discard it
return;
}
if (!fetchDetailsCalled && purchases.list.Any())
{
m_AssetStoreClient.FetchDetails(purchases.productIds);
}
// only try to rebuild the list immediately if we are already on the `AssetStore` tab.
// if not we'll just wait for tab switch which will trigger the rebuild as well
if (m_PackageFiltering.currentFilterTab == PackageFilterTab.AssetStore)
{
HashSet <string> removed = null;
List <string> added = null;
if (purchases.startIndex == 0)
{
removed = oldPackageIds;
added = new List <string>();
foreach (var id in newPackageIds)
{
if (removed.Contains(id))
{
removed.Remove(id);
}
else
{
added.Add(id);
}
}
}
else if (purchases.startIndex == oldPackageIds.Count)
{
added = newPackageIds;
}
var addedPackages = added?.Select(id => m_PackageDatabase.GetPackage(id));
var removedPackages = removed?.Select(id => m_PackageDatabase.GetPackage(id));
TriggerOnListUpdate(addedPackages, removedPackages, false);
}
RefreshVisualStates();
}
public async Task PopulateAsync(
Type readModelType,
CancellationToken cancellationToken)
{
var stopwatch = Stopwatch.StartNew();
var readStoreManagers = ResolveReadStoreManagers(readModelType);
var readModelTypes = new[]
{
typeof(IAmReadModelFor <, ,>),
typeof(IAmAsyncReadModelFor <, ,>)
};
var aggregateEventTypes = new HashSet <Type>(readModelType
.GetTypeInfo()
.GetInterfaces()
.Where(i => i.GetTypeInfo().IsGenericType &&
readModelTypes.Contains(i.GetGenericTypeDefinition()))
.Select(i => i.GetTypeInfo().GetGenericArguments()[2]));
_log.Verbose(() => string.Format(
"Read model '{0}' is interested in these aggregate events: {1}",
readModelType.PrettyPrint(),
string.Join(", ", aggregateEventTypes.Select(e => e.PrettyPrint()).OrderBy(s => s))));
long totalEvents = 0;
long relevantEvents = 0;
var currentPosition = GlobalPosition.Start;
while (true)
{
_log.Verbose(() => string.Format(
"Loading events starting from {0} and the next {1} for populating '{2}'",
currentPosition,
_configuration.PopulateReadModelEventPageSize,
readModelType.PrettyPrint()));
var allEventsPage = await _eventStore.LoadAllEventsAsync(
currentPosition,
_configuration.PopulateReadModelEventPageSize,
cancellationToken)
.ConfigureAwait(false);
totalEvents += allEventsPage.DomainEvents.Count;
currentPosition = allEventsPage.NextGlobalPosition;
if (!allEventsPage.DomainEvents.Any())
{
_log.Verbose(() => $"No more events in event store, stopping population of read model '{readModelType.PrettyPrint()}'");
break;
}
var domainEvents = allEventsPage.DomainEvents
.Where(e => aggregateEventTypes.Contains(e.EventType))
.ToList();
relevantEvents += domainEvents.Count;
if (!domainEvents.Any())
{
continue;
}
var applyTasks = readStoreManagers
.Select(m => m.UpdateReadStoresAsync(domainEvents, cancellationToken));
await Task.WhenAll(applyTasks).ConfigureAwait(false);
}
stopwatch.Stop();
_log.Information(
"Population of read model '{0}' took {1:0.###} seconds, in which {2} events was loaded and {3} was relevant",
readModelType.PrettyPrint(),
stopwatch.Elapsed.TotalSeconds,
totalEvents,
relevantEvents);
}
public IEnumerable <IFile> GetFiles()
{
return(_files.Select(x => new InlinePackageFile(_package, x)));
}
public void ValidateAAPLOptionChainSecurityIdentifiers()
{
var chainProvider = new BacktestingOptionChainProvider();
var aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
var chains = new HashSet <Symbol>();
var expectedChains = File.ReadAllLines("TestData/aapl_chain.csv")
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToDictionary(x => x, _ => false);
Assert.AreNotEqual(0, expectedChains.Count);
var start = new DateTime(2020, 1, 1);
var end = new DateTime(2020, 7, 1);
foreach (var date in Time.EachDay(start, end))
{
if (USHoliday.Dates.Contains(date) || date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday)
{
continue;
}
foreach (var symbol in chainProvider.GetOptionContractList(aapl, date))
{
chains.Add(symbol);
}
}
var fails = new HashSet <Symbol>();
foreach (var chain in chains)
{
if (expectedChains.ContainsKey(chain.ID.ToString()))
{
expectedChains[chain.ID.ToString()] = true;
continue;
}
fails.Add(chain);
}
Assert.AreEqual(0, fails.Count, $"The following option Symbols were not found in the expected chain: \n{string.Join("\n", fails.Select(x => x.ID.ToString()))}");
Assert.IsTrue(expectedChains.All(kvp => kvp.Value), $"The following option Symbols were not loaded: \n{string.Join("\n", expectedChains.Where(kvp => !kvp.Value).Select(x => x.Key))}");
}
/// <summary>
/// This enables scanning for and loading of plug-ins
/// </summary>
/// <param name="hostBuilder">IHostBuilder</param>
private static void ConfigurePluginScanAndLoad(IHostBuilder hostBuilder)
{
// Configure the actual scanning & loading
hostBuilder.ConfigureServices((hostBuilderContext, serviceCollection) =>
{
hostBuilder.Properties.TryRetrievePluginBuilder(out var pluginBuilder);
if (pluginBuilder.UseContentRoot)
{
var contentRootPath = hostBuilderContext.HostingEnvironment.ContentRootPath;
pluginBuilder.AddScanDirectories(contentRootPath);
}
var scannedAssemblies = new HashSet <Assembly>();
if (pluginBuilder.FrameworkDirectories.Count > 0)
{
foreach (var frameworkScanRoot in pluginBuilder.FrameworkDirectories)
{
// Do the globbing and try to load the framework files into the default AssemblyLoadContext
foreach (var frameworkAssemblyPath in pluginBuilder.FrameworkMatcher.GetResultsInFullPath(frameworkScanRoot))
{
var frameworkAssemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(frameworkAssemblyPath));
if (AssemblyLoadContext.Default.TryGetAssembly(frameworkAssemblyName, out var alreadyLoadedAssembly))
{
scannedAssemblies.Add(alreadyLoadedAssembly);
continue;
}
// TODO: Log the loading?
var loadedAssembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(frameworkAssemblyPath);
if (loadedAssembly != null)
{
scannedAssemblies.Add(loadedAssembly);
}
}
}
}
if (pluginBuilder.PluginDirectories.Count > 0)
{
foreach (var pluginScanRootPath in pluginBuilder.PluginDirectories)
{
// Do the globbing and try to load the plug-ins
var pluginPaths = pluginBuilder.PluginMatcher.GetResultsInFullPath(pluginScanRootPath);
// Use the globbed files, and load the assemblies
var pluginAssemblies = pluginPaths
.Select(LoadPlugin)
.Where(plugin => plugin != null);
foreach (var pluginAssembly in pluginAssemblies)
{
scannedAssemblies.Add(pluginAssembly);
}
}
}
var plugins = scannedAssemblies.Select(CreatePluginInstance).Where(plugin => plugin != null).OrderBy(plugin => plugin.GetOrder());
foreach (var plugin in plugins)
{
plugin.ConfigureHost(hostBuilderContext, serviceCollection);
}
});
}
private async Task FillDescriptionNotExistsEntities(StringBuilder strFile, HashSet <Guid> workflowsWithEntities, Dictionary <EntityReference, HashSet <Guid> > list)
{
{
var listToDelete = new List <EntityReference>();
foreach (var itemRef in list.Keys)
{
try
{
var entityMetadata = _descriptor.MetadataSource.GetEntityMetadata(itemRef.LogicalName);
if (entityMetadata != null)
{
var repositoryGeneric = new GenericRepository(_service, entityMetadata);
var entity = await repositoryGeneric.GetEntityByIdAsync(itemRef.Id, ColumnSetInstances.AllColumns);
if (entity != null)
{
listToDelete.Add(itemRef);
}
}
}
catch (Exception)
{
}
}
foreach (var item in listToDelete)
{
list.Remove(item);
}
workflowsWithEntities.Clear();
foreach (var set in list.Values)
{
foreach (var item in set)
{
workflowsWithEntities.Add(item);
}
}
}
if (list.Count == 0)
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(this._iWriteToOutput.WriteToOutput(_service.ConnectionData, "No used not exists entities in workflows."))
;
return;
}
strFile
.AppendLine()
.AppendLine()
.AppendFormat(this._iWriteToOutput.WriteToOutput(_service.ConnectionData, "Used Not Exists Entities {0}", list.Count)).AppendLine()
;
var orderedList = list.Keys.OrderBy(i => i.LogicalName).ThenBy(i => i.Name).ThenBy(i => i.Id);
{
FormatTextTableHandler table = new FormatTextTableHandler();
table.SetHeader(nameof(EntityReference.LogicalName), nameof(EntityReference.Name), nameof(EntityReference.Id), "Url");
foreach (var item in orderedList)
{
var values = new List <string>()
{
item.LogicalName, item.Name, item.Id.ToString()
};
var url = _service.ConnectionData.GetEntityInstanceUrl(item.LogicalName, item.Id);
if (!string.IsNullOrEmpty(url))
{
values.Add(url);
}
table.AddLine(values);
}
table.GetFormatedLines(false).ForEach(s => strFile.AppendLine(tabspacer + s));
}
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
.AppendLine()
.AppendLine()
.AppendLine()
;
strFile.AppendFormat("Used Not Exists Entities Full Information {0}", list.Count).AppendLine();
foreach (var item in orderedList)
{
strFile
.AppendLine()
.AppendLine()
.AppendLine();
FormatTextTableHandler table = new FormatTextTableHandler();
table.SetHeader(nameof(EntityReference.LogicalName), nameof(EntityReference.Name), nameof(EntityReference.Id));
table.AddLine(item.LogicalName, item.Name, item.Id.ToString());
table.GetFormatedLines(false).ForEach(s => strFile.AppendLine(s));
var url = _service.ConnectionData.GetEntityInstanceUrl(item.LogicalName, item.Id);
if (!string.IsNullOrEmpty(url))
{
strFile.AppendLine("Url:");
strFile.AppendLine(url);
}
strFile.AppendLine();
var message = await _descriptor.GetSolutionComponentsDescriptionAsync(list[item].Select(id => new SolutionComponent()
{
ObjectId = id,
ComponentType = new OptionSetValue((int)ComponentType.Workflow),
}));
strFile
.AppendLine("This entity Used By Workflows:")
.AppendLine(message)
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine(new string('-', 150))
;
}
if (workflowsWithEntities.Any())
{
strFile
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine()
.AppendLine("These entities Used By Workflows:")
;
var desc = await _descriptor.GetSolutionComponentsDescriptionAsync(workflowsWithEntities.Select(id => new SolutionComponent()
{
ObjectId = id,
ComponentType = new OptionSetValue((int)ComponentType.Workflow),
}));
strFile.AppendLine(desc);
}
}
public IEnumerable <String> GetSecurityDBNames(String ServerName = null)
{
return((String.IsNullOrWhiteSpace(ServerName)) ? _ICP4SecurityServers?.Select(x => x.SecurityDB.Name)
: _ICP4SecurityServers?.Where(x => x.Name == ServerName)
?.Select(x => x.SecurityDB.Name));
}
public IEnumerable <IFile> GetChildren()
{
return(_folders.Select(x => new InlinePackageFile(_package, x)));
}
