public static ISet<int> GetSchemaVersionsForSubscription(List<string> capabilities)
{
//The first two schema versions follow the old regex, and versions 3 on follow the new one.
if (capabilities == null)
{
throw new ArgumentNullException("capabilities");
}
var matchesOld = capabilities.Select(s => ClustersContractCapabilityRegexOld.Match(s)).Where(match => match.Success).ToList();
var schemaVersions = new HashSet<int>(matchesOld.Select(m => Int32.Parse(m.Groups[1].Value, CultureInfo.CurrentCulture)).ToList());
var matchesNew = capabilities.Select(s => ClustersContractCapabilityRegex.Match(s)).Where(match => match.Success).ToList();
if (matchesNew.Count != 0)
{
schemaVersions.UnionWith(
matchesNew.Select(m => Int32.Parse(m.Groups[1].Value, CultureInfo.CurrentCulture)));
}
if (schemaVersions == null || !schemaVersions.Any())
{
throw new NotSupportedException("This subscription is not enabled for the clusters contract.");
}
return schemaVersions;
}
public static void ApplySetPieces(World world)
{
var map = world.Map;
int w = map.Width, h = map.Height;
Random rand = new Random();
HashSet<Rect> rects = new HashSet<Rect>();
foreach (var dat in setPieces)
{
int size = dat.Item1.Size;
int count = rand.Next(dat.Item2, dat.Item3);
for (int i = 0; i < count; i++)
{
IntPoint pt = new IntPoint();
Rect rect;
int max = 50;
do
{
pt.X = rand.Next(0, w);
pt.Y = rand.Next(0, h);
rect = new Rect() { x = pt.X, y = pt.Y, w = size, h = size };
max--;
} while ((Array.IndexOf(dat.Item4, map[pt.X, pt.Y].Terrain) == -1 ||
rects.Any(_ => Rect.Intersects(rect, _))) &&
max > 0);
if (max <= 0) continue;
dat.Item1.RenderSetPiece(world, pt);
rects.Add(rect);
}
}
}
public PathData pathTo(Pos target, Pos currentLocation, Tile[][] board, int spikeCost = 5)
{
Dictionary<string, InternalTile> Navigated = new Dictionary<string, InternalTile>();
HashSet<InternalTile> Closed = new HashSet<InternalTile>();
InternalTile beginning = new InternalTile() { TilePos = currentLocation, Weight = 0 };
HashSet<InternalTile> Opened = new HashSet<InternalTile> {
beginning
};
Dictionary<string, int> Scores = new Dictionary<string, int> {
{GetKey(beginning.TilePos.x, beginning.TilePos.y), beginning.Weight}
};
Dictionary<string, float> FullScores = new Dictionary<string, float> {
{GetKey(beginning.TilePos.x, beginning.TilePos.y), GetDistance(currentLocation, target)}
};
while (Opened.Any()) {
InternalTile lowest = Opened.First(tile => GetKey(tile.TilePos.x, tile.TilePos.y) == GetLowestCostTile(FullScores, Opened));
if (lowest.TilePos.x == target.x && lowest.TilePos.y == target.y) {
return ReconstructPath(Navigated, target);
}
Opened.Remove(lowest);
Closed.Add(lowest);
foreach (Pos neighbor in GetNeighbors(lowest.TilePos, board.Length, board[0].Length)) {
if (Closed.Any(tile => tile.TilePos.x == neighbor.x && tile.TilePos.y == neighbor.y)) {
continue;
}
string neighborKey = GetKey(neighbor.x, neighbor.y);
int curScore = Scores[GetKey(lowest.TilePos.x, lowest.TilePos.y)] + 1;
if (!Opened.Any(tile => tile.TilePos.x == neighbor.x && tile.TilePos.y == neighbor.y)) {
Opened.Add(new InternalTile { TilePos = new Pos { x = neighbor.x, y = neighbor.y } });
} else if (curScore >= (Scores.ContainsKey(neighborKey) ? Scores[neighborKey] : int.MaxValue)) {
continue;
}
Navigated.Add(neighborKey, lowest);
Scores.Add(neighborKey, curScore);
FullScores.Add(neighborKey, curScore + GetDistance(neighbor, target));
}
}
return null;
}
public async Task<IEnumerable<UserData>> Post(IEnumerable<ScoreData> scores, string p)
{
if (p != ConfigurationManager.AppSettings["SyncPass"])
return null;
var users = (await _userDataRepo.Get()).ToDictionary(x => x.UserId, x => x);
var usersToUpdate = new HashSet<UserData>();
foreach (var score in scores)
{
UserData user;
if (users.ContainsKey(score.UserId))
{
user = users[score.UserId];
}
else
{
user = new UserData { UserId = score.UserId };
users.Add(score.UserId, user);
usersToUpdate.Add(user);
}
if (user.Score != score.Score)
{
user.Score = score.Score;
usersToUpdate.Add(user);
}
}
if (usersToUpdate.Any())
await _userDataRepo.SaveBatch(usersToUpdate);
return users.Values;
}
/// <summary>
/// Business or validation rule implementation.
/// </summary>
/// <param name="context">Rule context object.</param>
protected override void Execute(RuleContext context)
{
var commands = (ProcessCommandEditList)context.InputPropertyValues[PrimaryProperty];
if (commands == null) return;
foreach (var command in commands)
{
var foundConfigurations = new HashSet<ProcessCommandSecurityConfigurationEdit>();
var command1 = command;
foreach (var configuration in command.SecurityConfigurationList.Where(configuration => !foundConfigurations.Any(f => f.RoleId == configuration.RoleId &&
f.StateGuid == configuration.StateGuid &&
f.BusinessUnitId == configuration.BusinessUnitId &&
f.PersonFieldSystemName == configuration.PersonFieldSystemName)
&& command1.SecurityConfigurationList.Any(x => !x.Equals(configuration) &&
x.RoleId == configuration.RoleId &&
x.StateGuid == configuration.StateGuid &&
x.BusinessUnitId == configuration.BusinessUnitId &&
x.PersonFieldSystemName == configuration.PersonFieldSystemName))
)
{
foundConfigurations.Add(configuration);
context.AddErrorResult(PrimaryProperty, string.Format(LanguageService.Translate("Rule_UniqueSecurityConfiguration"), command.CommandName));
}
}
}
public override void Generate()
{
Console.WriteLine("Generating Age ranges");
var uniqueAgeRanges = new HashSet<AgeRanx>();
while (uniqueAgeRanges.Count != this.Count)
{
var minAge = this.Random.GetInt(0, 20);
var maxAge = minAge + this.Random.GetInt(1, 5);
var newAgeRange = new AgeRanx
{
MaxAge = maxAge,
MinAge = minAge
};
if (!uniqueAgeRanges.Any(a => a.MinAge == minAge && a.MaxAge == maxAge))
{
uniqueAgeRanges.Add(newAgeRange);
}
}
var index = 0;
foreach (var uniqueAgeRange in uniqueAgeRanges)
{
Db.AgeRanges.Add(uniqueAgeRange);
index++;
if (index % 100 == 0)
{
Console.Write(".");
Db.SaveChanges();
}
}
Console.WriteLine("\nGenerating Age Ranges Done!");
}
public void Render(IGraphNode<LibraryDependency> root)
{
// tuples of <Library Name, Requested Version, Actual Version>
var results = new HashSet<Tuple<string, string, string>>();
root.DepthFirstPreOrderWalk(
(node, ancestors) =>
{
var dependency = node.Item;
if (IsLibraryMismatch(dependency))
{
results.Add(Tuple.Create(
dependency.Library.Identity.Name,
dependency.LibraryRange.VersionRange?.MinVersion.ToString(),
dependency.Library.Identity.Version?.ToString()));
}
return true;
});
if (results.Any())
{
var format = GetFormat(results, padding: 2);
RenderTitle(format);
RenderMismatches(format, results);
}
}
public IEnumerable<int> Parse(string message)
{
var lexer = new StringCalculatorLexer(message);
var delimiters = new HashSet<string>();
string numbersString = null;
foreach (var token in lexer.Read())
{
if (token is DelimiterToken)
{
delimiters.Add(token.Content);
}
if (token is NumbersToken)
{
numbersString = token.Content;
}
}
if (string.IsNullOrEmpty(numbersString))
{
return Enumerable.Empty<int>();
}
var numberSplitter = delimiters.Any() ?
delimiters.GenerateSplitter() :
_defaultSplitter;
return numberSplitter
.Split(numbersString)
.Select(int.Parse);
}
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);
}
public static IEnumerable<string> GetJarsFromPOM(this IMavenArtifactHandler handler, MavenPartialPOM pom)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (pom == null)
{
throw new ArgumentNullException("pom");
}
ISet<string> jarFilePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (MavenDependency dependency in pom.Dependencies)
{
string jarFilePath = handler.FetchArtifactJarFile(dependency);
if (jarFilePath != null)
{
Debug.Assert(!jarFilePaths.Contains(jarFilePath, StringComparer.OrdinalIgnoreCase), "Expecting full jar paths to be unique");
Debug.Assert(!jarFilePaths.Any(j => Path.GetFileName(j).Equals(Path.GetFileName(jarFilePath), StringComparison.OrdinalIgnoreCase)),
"Expecting jars file names to be unique");
jarFilePaths.Add(jarFilePath);
}
}
return jarFilePaths;
}
public IEnumerable<State> TransitiveClosure (
Func<SimpleTransition, bool> selector,
Func<SimpleTransition, bool> cancel)
{
var done = new HashSet<State> ();
var work = new HashSet<State> ();
work.Add (this);
while (work.Any ()) {
var q = work.First ();
work.Remove (q);
done.Add (q);
if (q.Delta == null) {
continue;
}
var ts = q.Delta
.Where (t => selector == null || selector (t))
.ToArray ();
if (cancel != null && ts.Any (cancel)) {
return null;
}
foreach (var qn in ts.Select (t => t.Next)) {
if (!done.Contains (qn)) {
work.Add (qn);
}
}
}
return done;
}
public long GetNextAvailableLong(List<long> values, bool returnZero)
{
if (values == null || !values.Any())
{
if (returnZero)
{
return 0;
}
else
{
return 1;
}
}
HashSet<long> hashSetValues = new HashSet<long>(values);
long x = hashSetValues.Min();
while (hashSetValues.Any(m => m == x))
{
x++;
if (x == 0 && !returnZero)
{
x++;
}
}
return x;
}
static int Main(string[] args)
{
var commandArguments = CommandArguments.Parse(args);
if (!string.IsNullOrEmpty(commandArguments.Error))
{
Console.WriteLine(commandArguments.Error);
return -1;
}
var returnCode = 0;
var options = commandArguments.ParsedOptions;
var modelsToProcess = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
if (!string.IsNullOrEmpty(options.ServiceModels))
{
foreach (var s in options.ServiceModels.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
modelsToProcess.Add(s);
}
}
try
{
if (options.CompileCustomizations) // Compile all servicename.customizations*.json files into one json file in bin
CustomizationCompiler.CompileServiceCustomizations(options.ModelsFolder);
var generationManifest = GenerationManifest.Load(options.Manifest, options.Versions, options.ModelsFolder);
foreach (var serviceConfig in generationManifest.ServiceConfigurations)
{
if (modelsToProcess.Any() && !modelsToProcess.Contains(serviceConfig.ModelName))
{
Console.WriteLine("Skipping model (not in -servicemodels set to process): {0} ({1})", serviceConfig.ModelName, serviceConfig.ModelPath);
continue;
}
Console.WriteLine("Processing model: {0} ({1})", serviceConfig.ModelName, serviceConfig.ModelPath);
var driver = new GeneratorDriver(serviceConfig, generationManifest, options);
driver.Execute();
}
GeneratorDriver.UpdateSolutionFiles(options);
GeneratorDriver.UpdateAssemblyVersionInfo(generationManifest, options);
GeneratorDriver.UpdateUnitTestProjectReferences(options);
}
catch (Exception e)
{
Console.Error.WriteLine("Error running generator: " + e.Message);
Console.Error.WriteLine(e.StackTrace);
returnCode = -1;
}
if (options.WaitOnExit)
{
Console.WriteLine();
Console.WriteLine("Generation complete. Press a key to exit.");
Console.ReadLine();
}
return returnCode;
}
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);
}
public void CustomizeCodeDom(CodeCompileUnit codeUnit, IServiceProvider services)
{
var types = codeUnit.Namespaces[0].Types;
var attributes = new HashSet<string>();
foreach (var type in types.Cast<CodeTypeDeclaration>().
Where(type => type.IsClass && !type.IsContextType()))
{
attributes.Clear();
var @struct = new CodeTypeDeclaration {
Name = AttributeConstsStructName,
IsStruct = true,
TypeAttributes = TypeAttributes.Public
};
foreach (var member in from CodeTypeMember member in type.Members
let prop = member as CodeMemberProperty
where prop != null
select prop)
{
CreateAttributeConstForProperty(@struct, member, attributes);
}
if (attributes.Any())
{
type.Members.Insert(0, GenerateTypeWithoutEmptyLines(@struct));
}
}
}
public static IEnumerable<SyntaxNode> GetUnnecessaryImports(SemanticModel semanticModel, SyntaxNode root, CancellationToken cancellationToken)
{
var diagnostics = semanticModel.GetDiagnostics(cancellationToken: cancellationToken);
if (!diagnostics.Any())
{
return null;
}
var unnecessaryImports = new HashSet<UsingDirectiveSyntax>();
foreach (var diagnostic in diagnostics)
{
if (diagnostic.Id == "CS8019")
{
var node = root.FindNode(diagnostic.Location.SourceSpan) as UsingDirectiveSyntax;
if (node != null)
{
unnecessaryImports.Add(node);
}
}
}
if (cancellationToken.IsCancellationRequested || !unnecessaryImports.Any())
{
return null;
}
return unnecessaryImports;
}
public static bool CreatesNewLife(this Cell cell, ISet<Cell> cells, out ISet<Cell> newLife)
{
var emptyNeighbors = cellTransform.Select(t => cell + t).Where(c => !cells.Contains(c));
newLife = new HashSet<Cell>(emptyNeighbors.Where(n => GetNeighbors(n, cells).Count() == 3));
return newLife.Any();
}
protected override void ProcessPackage(PackageProvider provider, IEnumerable<string> searchKey, SoftwareIdentity package) {
try {
base.ProcessPackage(provider, searchKey, package);
// return the object to the caller now.
WriteObject(package);
if (IncludeDependencies) {
var missingDependencies = new HashSet<string>();
foreach (var dep in package.Dependencies) {
// note: future work may be needed if the package sources currently selected by the user don't
// contain the dependencies.
var dependendcies = PackageManagementService.FindPackageByCanonicalId(dep, this);
var depPkg = dependendcies.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).FirstOrDefault();
if (depPkg == null) {
missingDependencies.Add(dep);
Warning(Constants.Messages.UnableToFindDependencyPackage, dep);
} else {
ProcessPackage(depPkg.Provider, searchKey.Select(each => each + depPkg.Name).ToArray(), depPkg);
}
}
if (missingDependencies.Any()) {
Error(Constants.Errors.UnableToFindDependencyPackage, missingDependencies.JoinWithComma());
}
}
} catch (Exception ex) {
Debug("Calling ProcessPackage {0}", ex.ToString());
}
}
private void OutputReferences(Output result, DependencyGraph graph, Library lib, string type)
{
result.AppendLine(GetName(lib) + ":");
var directDeps = new HashSet<Library>(graph.OutEdges(lib)
.Select(d => d.Target));
result.IncreaseIndent();
result.AppendLine("Direct " + type + ":");
result.IncreaseIndent();
Output(result, directDeps);
result.DecreaseIndent();
result.DecreaseIndent();
if (directDeps.Any())
{
var indirectDeps = ComputeIndirectDeps(graph, lib)
.Where(d => !directDeps.Contains(d))
// ReSharper disable once PossibleUnintendedReferenceComparison
.Where(d => d != lib);
result.IncreaseIndent();
result.AppendLine("Indirect " + type + ":");
result.IncreaseIndent();
Output(result, indirectDeps);
result.DecreaseIndent();
result.DecreaseIndent();
}
result.AppendLine();
}
public void all_events_are_checked()
{
var eventAssembly = typeof (CreditCourseCreatedEvent).Assembly;
var testAssembly = Assembly.GetExecutingAssembly();
var eventTypes = eventAssembly.GetTypes()
.Where(t => t.IsClass
&& !t.IsAbstract
&& typeof (IEvent).IsAssignableFrom(t));
var eventFixtureTypes = testAssembly.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract);
var missingTests = new HashSet<Type>();
foreach (var eventType in eventTypes)
{
var fixtureBaseType = typeof (EventSerializationFixture<>)
.MakeGenericType(eventType);
var fixtureTypes = eventFixtureTypes
.Where(t => fixtureBaseType.IsAssignableFrom(t))
.ToArray();
if (!fixtureTypes.Any())
missingTests.Add(eventType);
}
if (missingTests.Any())
Assert.Fail("The following events are not being tested: {0}",
string.Join(Environment.NewLine, missingTests));
}
private static void Main()
{
var input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
var n = input[0];
var coord0 = new Coord(input[1], input[2]);
var rgcoord = new HashSet<Coord>();
for (var i = 0; i < n; i++)
{
input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
rgcoord.Add(new Coord(input[0], input[1]));
}
var d = 0;
while (rgcoord.Any())
{
d++;
var coord = rgcoord.First();
var vX = coord.x - coord0.x;
var vY = coord.y - coord0.y;
foreach (var coordT in rgcoord.ToList())
{
if (vY*(coordT.x - coord0.x) == vX*(coordT.y - coord0.y))
rgcoord.Remove(coordT);
}
}
Console.WriteLine(d);
}
public int[] FindBest()
{
var remaining = new HashSet<Point>(_cities);
var first = remaining.First();
var route = new List<Point> { first };
remaining.Remove(first);
var numericRoute = new List<int>{_cities.IndexOf(first)};
var distance = 0.0d;
while (remaining.Any())
{
var shortest = double.MaxValue;
Point next = null;
foreach (var p in remaining)
{
var d = Distance(route.Last(), p);
if (d < shortest)
{
shortest = d;
next = p;
}
}
route.Add(next);
numericRoute.Add(_cities.IndexOf(next));
remaining.Remove(next);
distance += shortest;
}
distance += Distance(route.First(), route.Last());
Console.WriteLine("Distance calculated in closestneighbour: " + distance);
return numericRoute.ToArray();
}
private static void FindIndirectCircularReferences(ISet<Node> childList)
{
var toIgnore = new HashSet<Node>();
foreach (var node in childList.ToHashSet())
{
if(toIgnore.Contains(node))
continue;
var path = new HashSet<Node>();
if (IndirectlyDependsOnItself(node, node, ref path))
{
path.Add(node);
toIgnore.UnionWith(path);
childList.ExceptWith(path);
var dependantOnCircularDependencies = childList.Where(x => path.Any(x.DependsOn));
var cirularHolder = new CircularDependencyHolderNode(path);
foreach (var dependantOnCircularDependency in dependantOnCircularDependencies)
{
//Remove all dependencies on nodes in the path
dependantOnCircularDependency.SiblingDependencies.RemoveWhere(x => path.Contains(x));
//Add dependency on circular holder
dependantOnCircularDependency.SiblingDependencies.Add(cirularHolder);
}
//Add all dependencies in the path to the new node
cirularHolder.SiblingDependencies.UnionWith(path.SiblingDependencies().Except(path)); //Should not be dependant on themselves
childList.Add(cirularHolder);
}
}
}
public override QState Initialize()
{
WriteOutput("Dimensions: " + width + "x" + height);
self = new Point(start.X, start.Y);
score = 0;
walls = new Point[] { };
// Generate Walls Randomly
if (wallDensity > 0)
{
HashSet<Point> bestPathSoFar = new HashSet<Point>();
WriteOutput("Generating walls randomly with density target of " + wallDensity + "...");
for (int w = 0; w < width; w++)
{
for (int h = 0; h < height; h++)
{
double r = random.NextDouble();
//WriteOutput("Wall Probability for " + w + "x" + h + ": " + r+" vs threshold "+walls);
if (r < wallDensity)
{
//WriteOutput("Wall created at " + w + "x" + h);
Point newWall = new Point(w, h);
if (start == newWall || goal == newWall) continue;
Point[] tempWalls = walls.Concat(new Point[] { newWall }).ToArray();
QState tempState = new Maze() { maze = maze, self = self, goal = goal, width = width, height = height, walls = tempWalls};
if (!bestPathSoFar.Any() || bestPathSoFar.Contains(newWall))
{
QSearchResult path = new QSearch().AStar(tempState);
if (path != null)
{
bestPathSoFar.Clear();
foreach (QState q in path.QStatesList)
bestPathSoFar.Add(((Maze)q).self);
walls = tempWalls;
}
}
else walls = tempWalls;
}
}
}
WriteOutput("Maze generation complete.");
}
opponent = new List<Point>();
for (int i = 0; i < opponents; i++)
opponent.Add(new Point(goal.X, goal.Y));
if (!HideOutput)
{
ManualResetEvent wait = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(new WaitCallback(CreateGUI), new object[] { width, height, self.X, self.Y, goal.X, goal.Y, walls, this, wait });
wait.WaitOne();
}
return new Maze() { width = width, height = height, self = self, goal = goal, walls = walls, wallDensity = wallDensity, opponent = opponent, opponentDifficulty = opponentDifficulty, random = random, maze = maze, start = start, opponents = opponents, bestOpponentPath = bestOpponentPath, score = score };
}
/// <summary>
/// When the tessellated solid is sliced at the specified plane, the contact surfaces are
/// described by the return ContactData object. This is a non-destructive function typically
/// used to find the shape and size of 2D surface on the prescribed plane..
/// </summary>
/// <param name="plane">The plane.</param>
/// <param name="ts">The ts.</param>
/// <returns>ContactData.</returns>
/// <exception cref="System.Exception">Contact Edges found that are not contained in loop.</exception>
public static ContactData DefineContact(Flat plane, TessellatedSolid ts)
{
var vertexDistancesToPlane = new double[ts.NumberOfVertices];
for (int i = 0; i < ts.NumberOfVertices; i++)
vertexDistancesToPlane[i] = ts.Vertices[i].Position.dotProduct(plane.Normal) - plane.DistanceToOrigin;
// the edges serve as the easiest way to identify where the solid is interacting with the plane.
// Instead of a foreach, the while loop lets us look ahead to known edges that are irrelevant.
var edgeHashSet = new HashSet<Edge>(ts.Edges);
// Contact elements are constructed and then later arranged into loops. Loops make up the returned object, ContactData.
var straddleContactElts = new List<ContactElement>();
var inPlaneContactElts = new List<CoincidentEdgeContactElement>();
while (edgeHashSet.Any())
{
// instead of the foreach, we have this while statement and these first 2 lines to enumerate over the edges.
var edge = edgeHashSet.First();
edgeHashSet.Remove(edge);
var toDistance = vertexDistancesToPlane[edge.To.IndexInList];
var fromDistance = vertexDistancesToPlane[edge.From.IndexInList];
if (StarMath.IsNegligible(toDistance) && StarMath.IsNegligible(fromDistance))
ContactElement.MakeInPlaneContactElement(plane, edge, edgeHashSet, vertexDistancesToPlane,
inPlaneContactElts);
else if ((toDistance > 0 && fromDistance < 0)
|| (toDistance < 0 && fromDistance > 0))
straddleContactElts.Add(new ThroughFaceContactElement(plane, edge, toDistance));
}
foreach (var contactElement in inPlaneContactElts)
{
// next, we find any additional vertices that just touch the plane but don't have in-plane edges
// to facilitate this we negate all vertices already captures in the inPlaneContactElts
vertexDistancesToPlane[contactElement.StartVertex.IndexInList] = double.NaN;
vertexDistancesToPlane[contactElement.EndVertex.IndexInList] = double.NaN;
}
for (int i = 0; i < ts.NumberOfVertices; i++)
{
if (!StarMath.IsNegligible(vertexDistancesToPlane[i])) continue;
var v = ts.Vertices[i];
PolygonalFace negativeFace, positiveFace;
if (ThroughVertexContactElement.FindNegativeAndPositiveFaces(plane, v, vertexDistancesToPlane,
out negativeFace, out positiveFace))
straddleContactElts.Add(new ThroughVertexContactElement(v, negativeFace, positiveFace));
}
straddleContactElts.AddRange(inPlaneContactElts);
var loops = new List<Loop>();
var numberOfTries = 0;
while (straddleContactElts.Any() && numberOfTries < straddleContactElts.Count)
{
// now build loops from stringing together contact elements
var loop = FindLoop(plane, straddleContactElts, vertexDistancesToPlane);
if (loop != null)
{
Debug.WriteLine(loops.Count + ": " + loop.MakeDebugContactString() + " ");
loops.Add(loop);
numberOfTries = 0;
}
else numberOfTries++;
}
if (straddleContactElts.Any()) Debug.WriteLine("Contact Edges found that are not contained in loop.");
return new ContactData(loops);
}
public void HashSetExtensions_AnyWithPredicate_ReturnsTrueIfHashSetContainsMatchingItems()
{
var set = new HashSet<Int32>() { 1, 2, 3 };
var result = set.Any(x => x % 2 == 0);
TheResultingValue(result).ShouldBe(true);
}
public void HashSetExtensions_Any_ReturnsTrueIfHashSetContainsItems()
{
var set = new HashSet<Int32>() { 1 };
var result = set.Any();
TheResultingValue(result).ShouldBe(true);
}
public void HashSetExtensions_Any_ReturnsFalseIfHashSetDoesNotContainItems()
{
var set = new HashSet<Int32>();
var result = set.Any();
TheResultingValue(result).ShouldBe(false);
}
public string ValidateFile(string pathToFile)
{
try
{
var doc = XDocument.Load(pathToFile);
var root = doc.Root;
if (root.Name.LocalName != SharedConstants.AdditionalFieldsTag)
return "Not valid custom properties file";
if (!root.HasElements)
return null; // CustomFields are optional.
var requiredAttrs = new HashSet<string>
{
"name",
"class",
"type",
Key // Special attr added so fast xml splitter can find each one.
};
var optionalAttrs = new HashSet<string>
{
"destclass",
"wsSelector",
"helpString",
"listRoot",
"label"
};
foreach (var customFieldElement in root.Elements(SharedConstants.CustomField))
{
if (requiredAttrs
.Any(requiredAttr => customFieldElement.Attribute(requiredAttr) == null))
{
return "Missing required custom property attribute";
}
if (customFieldElement.Attributes()
.Any(attribute => !requiredAttrs.Contains(attribute.Name.LocalName)
&& !optionalAttrs.Contains(attribute.Name.LocalName)))
{
return "Contains unrecognized attribute";
}
// Make sure 'key' attr is class+name.
if (customFieldElement.Attribute("class").Value + customFieldElement.Attribute("name").Value != customFieldElement.Attribute(Key).Value)
return "Mis-matched 'key' attribute with property class+name atributes";
if (customFieldElement.HasElements)
return "Contains illegal child element";
}
MetadataCache.MdCache.AddCustomPropInfo(new MergeOrder(
pathToFile, pathToFile, pathToFile,
new MergeSituation(pathToFile, "", "", "", "", MergeOrder.ConflictHandlingModeChoices.WeWin)));
return null;
}
catch (Exception e)
{
return e.Message;
}
}
public static void AssertLinesInclude(this DocumentAnalyzer actual, params LineSpan[] expected)
{
var missingLines = new HashSet<LineSpan>(expected).Except(actual.GetAllLines());
if (missingLines.Any()) {
Assert.Fail("Lines not found:\r\n{0}\r\n\r\nActual lines:\r\n{1}",
missingLines.ToFormattedString(),
actual.GetAllLines().ToFormattedString());
}
}
