public override void OnExecute(CommandEventArgs e)
{
GitPushArgs args = new GitPushArgs();
string repositoryRoot;
var repositoryRoots = new HashSet<string>(FileSystemUtil.StringComparer);
foreach (var projectRoot in GetAllRoots(e))
{
if (
GitTools.TryGetRepositoryRoot(projectRoot.FullPath, out repositoryRoot) &&
!repositoryRoots.Contains(repositoryRoot)
)
repositoryRoots.Add(repositoryRoot);
}
if (repositoryRoots.Count > 1)
{
throw new InvalidOperationException("Pushing of multiple repository roots is not supported");
}
repositoryRoot = repositoryRoots.Single();
switch (e.Command)
{
case VisualGitCommand.PendingChangesPushSpecificBranch:
case VisualGitCommand.PendingChangesPushSpecificTag:
if (!QueryParameters(e, repositoryRoot, args))
return;
break;
}
ProgressRunnerArgs pa = new ProgressRunnerArgs();
pa.CreateLog = true;
pa.TransportClientArgs = args;
GitException exception = null;
e.GetService<IProgressRunner>().RunModal(CommandStrings.PushingSolution, pa,
delegate(object sender, ProgressWorkerArgs a)
{
using (var client = e.GetService<IGitClientPool>().GetNoUIClient())
{
try
{
client.Push(repositoryRoot, args);
}
catch (GitException ex)
{
exception = ex;
}
}
});
if (exception != null)
{
e.GetService<IVisualGitErrorHandler>().OnWarning(exception);
}
}
/// <summary>
/// Get node collection from dataGridView
/// </summary>
/// <returns>HashSet of nodes</returns>
public HashSet<Node> GetNodes()
{
HashSet<Node> Nodes = new HashSet<Node>();
// Enlist all nodes
for (int row = 0; row < dataTable.Rows.Count; row++)
Nodes.Add(new Node((string)dataTable.Rows[row][0], (int)dataTable.Rows[row][1]));
// Create dependencies
for (int row = 0; row < dataTable.Rows.Count; row++)
if (dataTable.Rows[row][2] != null)
foreach (string dependency in dataTable.Rows[row][2].ToString().Split(separators, StringSplitOptions.RemoveEmptyEntries))
Nodes.ElementAt(row).Dependencies.Add(Nodes.Single(new Func<Node, bool>(delegate(Node node)
{
return node.ID == dependency;
})));
return Nodes;
}
/// <summary>
/// Take a Dictionary of pins and write it to an XML file
/// </summary>
/// <param name="pinMap">A Dictionary of frame X and Y rotations to a list of pins on that frame</param>
/// <param name="outfile">The file to write the formatted XML to</param>
public void Pack(Dictionary<Tuple<int, int>, List<Pin>> pinMap, string outfile)
{
List<FrameData> frames = new List<FrameData>();
HashSet<DissectionPinData> pins = new HashSet<DissectionPinData>();
int nextId = 0;
foreach (var pair in pinMap)
{
List<Pin> framePins = pair.Value; // All the pins on this frame
Tuple<int, int> frame = pair.Key; // The 2D rotation of this frame
FrameData frameData = new FrameData(); // Data for the frame to be represented in XML
frameData.Rotation = new Vector3(frame.Item1, frame.Item2, 0.0f);
List<FramePinData> framePinDatas = new List<FramePinData>(); // The links between this frame and its pins
foreach (Pin pin in framePins)
{
DissectionPinData data = ConvertToData(pin);
if (pins.Add(data))
{
// This pin doesn't already exist, so give it an id
data.Id = nextId++;
}
else
{
// This pin is in the HashSet so get the original instance
data = pins.Single((DissectionPinData x) => { return x.Equals(data); });
}
framePinDatas.Add(new FramePinData(new Vector2(pin.X, pin.Y), data.Id));
}
frameData.Pins = framePinDatas.ToArray();
frames.Add(frameData);
}
PinContainer container = new PinContainer();
container.Frames = frames.ToArray();
container.Pins = pins.ToArray();
WriteXml(container, outfile);
}
private double CalculateRPNValue(Stack<string> RPNStack, IEnumerable<SolvedCalculatorParameter> parameters)
{
var resultStack = new Stack<double>();
var parameterSet = new HashSet<SolvedCalculatorParameter>(parameters);
while (RPNStack.Count > 0) {
var val = RPNStack.Pop();
if (IsNumber(val)) {
resultStack.Push(double.Parse(val.Replace('.', ',')));
} else if (parameterSet.Any(x => x.Name == val)) {
var paramVal = parameterSet.Single(x => x.Name == val);
resultStack.Push(paramVal.Value);
} else {
var op = this.OperatorFactory.GetOperatorByCode(val);
if (resultStack.Count < op.ParameterCount) {
throw new CalculatorException(string.Format("Not enough parameters for function {0}", op.Name));
}
var operatorParams = new List<double>();
for (int i = 0; i < op.ParameterCount; i++) {
operatorParams.Add(resultStack.Pop());
}
operatorParams.Reverse();
var operationResult = op.DoOperation(operatorParams);
resultStack.Push(operationResult);
}
}
if (resultStack.Count > 1) {
throw new CalculatorException("The equation has too many values");
}
return resultStack.Pop();
}
void UpdateCompilerComboBox()
{
if (listView.SelectedItems.Count > 0) {
// Fetch list of available compiler versions
HashSet<CompilerVersion> availableVersionsSet = new HashSet<CompilerVersion>();
HashSet<CompilerVersion> currentVersions = new HashSet<CompilerVersion>();
foreach (Entry entry in listView.SelectedItems) {
if (entry.CompilerVersion != null)
currentVersions.Add(entry.CompilerVersion);
availableVersionsSet.AddRange(entry.Project.GetAvailableCompilerVersions());
}
List<CompilerVersion> availableVersions = availableVersionsSet.OrderBy(n => n.MSBuildVersion).ThenBy(n => n.DisplayName).ToList();
if (currentVersions.Count != 1) {
availableVersions.Insert(0, new UnchangedCompilerVersion());
}
// Assign available versions to newVersionComboBox
// Unless the user has already chosen a version, automatically set the selection to the
// current version of the chosen projects, or to 'do not change' if there are different
// current versions.
newCompilerSelectionChangingByCode = true;
newVersionComboBox.ItemsSource = availableVersions;
CompilerVersion oldSelectedVersion = newVersionComboBox.SelectedValue as CompilerVersion;
if (!newCompilerSelectionSetByUser || oldSelectedVersion == null) {
newCompilerSelectionSetByUser = false;
if (currentVersions.Count == 1)
newVersionComboBox.SelectedValue = currentVersions.Single();
else
newVersionComboBox.SelectedValue = new UnchangedCompilerVersion();
}
newCompilerSelectionChangingByCode = false;
UpdateTargetFrameworkComboBox();
}
}
private void btnDeleteCommander_Click(object sender, EventArgs e)
{
var cells = dataGridViewCommanders.SelectedCells;
HashSet<int> rowindexes = new HashSet<int>();
foreach (var cell in cells.OfType<DataGridViewCell>())
{
if (!rowindexes.Contains(cell.RowIndex))
{
rowindexes.Add(cell.RowIndex);
}
}
if (rowindexes.Count == 1)
{
var row = dataGridViewCommanders.Rows[rowindexes.Single()].DataBoundItem as EDCommander;
var result = MessageBox.Show("Do you wish to delete commander " + row.Name + "?", "Delete commander", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (result == DialogResult.Yes)
{
EDDConfig.Instance.DeleteCommander(row);
_discoveryForm.TravelControl.LoadCommandersListBox();
UpdateCommandersListBox();
_discoveryForm.RefreshHistoryAsync(); // will do a new parse on commander list adding/removing scanners
}
}
}
public CimInstanceRegularFilter(string propertyName, IEnumerable allowedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
{
HashSet<BehaviorOnNoMatch> behaviorOnNoMatches = new HashSet<BehaviorOnNoMatch>();
foreach (object allowedPropertyValue in allowedPropertyValues)
{
ClientSideQuery.PropertyValueFilter propertyValueRegularFilter = new ClientSideQuery.PropertyValueRegularFilter(propertyName, allowedPropertyValue, wildcardsEnabled, behaviorOnNoMatch);
base.AddPropertyValueFilter(propertyValueRegularFilter);
behaviorOnNoMatches.Add(propertyValueRegularFilter.BehaviorOnNoMatch);
}
if (behaviorOnNoMatches.Count != 1)
{
base.BehaviorOnNoMatch = behaviorOnNoMatch;
return;
}
else
{
base.BehaviorOnNoMatch = behaviorOnNoMatches.Single<BehaviorOnNoMatch>();
return;
}
}
public CimInstanceRegularFilter(string propertyName, IEnumerable allowedPropertyValues, bool wildcardsEnabled, BehaviorOnNoMatch behaviorOnNoMatch)
{
var valueBehaviors = new HashSet<BehaviorOnNoMatch>();
foreach (object allowedPropertyValue in allowedPropertyValues)
{
PropertyValueFilter filter =
new PropertyValueRegularFilter(
propertyName,
allowedPropertyValue,
wildcardsEnabled,
behaviorOnNoMatch);
this.AddPropertyValueFilter(filter);
valueBehaviors.Add(filter.BehaviorOnNoMatch);
}
if (valueBehaviors.Count == 1)
{
this.BehaviorOnNoMatch = valueBehaviors.Single();
}
else
{
this.BehaviorOnNoMatch = behaviorOnNoMatch;
}
}
private void UpdateSeverityMenuItemsChecked()
{
_setSeverityErrorMenuItem.Checked = false;
_setSeverityWarningMenuItem.Checked = false;
_setSeverityInfoMenuItem.Checked = false;
_setSeverityHiddenMenuItem.Checked = false;
_setSeverityNoneMenuItem.Checked = false;
var workspace = TryGetWorkspace() as VisualStudioWorkspaceImpl;
if (workspace == null)
{
return;
}
HashSet<ReportDiagnostic> selectedItemSeverities = new HashSet<ReportDiagnostic>();
var groups = _tracker.SelectedDiagnosticItems.GroupBy(item => item.AnalyzerItem.AnalyzersFolder.ProjectId);
foreach (var group in groups)
{
var project = (AbstractProject)workspace.GetHostProject(group.Key);
IRuleSetFile ruleSet = project.RuleSetFile;
if (ruleSet != null)
{
var specificOptions = ruleSet.GetSpecificDiagnosticOptions();
foreach (var diagnosticItem in group)
{
ReportDiagnostic ruleSetSeverity;
if (specificOptions.TryGetValue(diagnosticItem.Descriptor.Id, out ruleSetSeverity))
{
selectedItemSeverities.Add(ruleSetSeverity);
}
else
{
// The rule has no setting.
selectedItemSeverities.Add(ReportDiagnostic.Default);
}
}
}
}
if (selectedItemSeverities.Count != 1)
{
return;
}
switch (selectedItemSeverities.Single())
{
case ReportDiagnostic.Default:
break;
case ReportDiagnostic.Error:
_setSeverityErrorMenuItem.Checked = true;
break;
case ReportDiagnostic.Warn:
_setSeverityWarningMenuItem.Checked = true;
break;
case ReportDiagnostic.Info:
_setSeverityInfoMenuItem.Checked = true;
break;
case ReportDiagnostic.Hidden:
_setSeverityHiddenMenuItem.Checked = true;
break;
case ReportDiagnostic.Suppress:
_setSeverityNoneMenuItem.Checked = true;
break;
default:
break;
}
}
/// <summary>
/// Determines whether the given query view matches the discriminator map pattern.
/// </summary>
internal static bool TryCreateDiscriminatorMap(EntitySet entitySet, DbExpression queryView, out DiscriminatorMap discriminatorMap)
{
discriminatorMap = null;
if (queryView.ExpressionKind != DbExpressionKind.Project) { return false; }
var project = (DbProjectExpression)queryView;
if (project.Projection.ExpressionKind != DbExpressionKind.Case) { return false; }
var caseExpression = (DbCaseExpression)project.Projection;
if (project.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.EntityType) { return false; }
// determine value domain by walking filter
if (project.Input.Expression.ExpressionKind != DbExpressionKind.Filter) { return false; }
var filterExpression = (DbFilterExpression)project.Input.Expression;
HashSet<object> discriminatorDomain = new HashSet<object>();
if (!ViewSimplifier.TryMatchDiscriminatorPredicate(filterExpression, (equalsExp, discriminatorValue) => discriminatorDomain.Add(discriminatorValue)))
{
return false;
}
var typeMap = new List<KeyValuePair<object, EntityType>>();
var propertyMap = new Dictionary<EdmProperty, DbExpression>();
var relPropertyMap = new Dictionary<Query.InternalTrees.RelProperty, DbExpression>();
var typeToRelPropertyMap = new Dictionary<EntityType, List<Query.InternalTrees.RelProperty>>();
DbPropertyExpression discriminator = null;
EdmProperty discriminatorProperty = null;
for (int i = 0; i < caseExpression.When.Count; i++)
{
var when = caseExpression.When[i];
var then = caseExpression.Then[i];
var projectionVariableName = project.Input.VariableName;
DbPropertyExpression currentDiscriminator;
object discriminatorValue;
if (!ViewSimplifier.TryMatchPropertyEqualsValue(when, projectionVariableName, out currentDiscriminator, out discriminatorValue)) { return false; }
// must be the same discriminator in every case
if (null == discriminatorProperty) { discriminatorProperty = (EdmProperty)currentDiscriminator.Property; }
else if (discriminatorProperty != currentDiscriminator.Property) { return false; }
discriminator = currentDiscriminator;
// right hand side must be entity type constructor
EntityType currentType;
if (!TryMatchEntityTypeConstructor(then, propertyMap, relPropertyMap, typeToRelPropertyMap, out currentType)) { return false; }
// remember type + discriminator value
typeMap.Add(new KeyValuePair<object, EntityType>(discriminatorValue, currentType));
// remove discriminator value from domain
discriminatorDomain.Remove(discriminatorValue);
}
// make sure only one member of discriminator domain remains...
if (1 != discriminatorDomain.Count) { return false; }
// check default case
EntityType elseType;
if (null == caseExpression.Else ||
!TryMatchEntityTypeConstructor(caseExpression.Else, propertyMap, relPropertyMap, typeToRelPropertyMap, out elseType)) { return false; }
typeMap.Add(new KeyValuePair<object, EntityType>(discriminatorDomain.Single(), elseType));
// Account for cases where some type in the hierarchy specifies a rel-property, but another
// type in the hierarchy does not
if (!CheckForMissingRelProperties(relPropertyMap, typeToRelPropertyMap))
{
return false;
}
// since the store may right-pad strings, ensure discriminator values are unique in their trimmed
// form
var discriminatorValues = typeMap.Select(map => map.Key);
int uniqueValueCount = discriminatorValues.Distinct(TrailingSpaceComparer.Instance).Count();
int valueCount = typeMap.Count;
if (uniqueValueCount != valueCount) { return false; }
discriminatorMap = new DiscriminatorMap(discriminator, typeMap, propertyMap, relPropertyMap, entitySet);
return true;
}
public override void OnExecute(CommandEventArgs e)
{
GitPullArgs args = new GitPullArgs();
string repositoryRoot;
var repositoryRoots = new HashSet<string>(FileSystemUtil.StringComparer);
foreach (var projectRoot in GetAllRoots(e))
{
if (
GitTools.TryGetRepositoryRoot(projectRoot.FullPath, out repositoryRoot) &&
!repositoryRoots.Contains(repositoryRoot)
)
repositoryRoots.Add(repositoryRoot);
}
if (repositoryRoots.Count > 1)
{
throw new InvalidOperationException("Pulling of multiple repository roots is not supported");
}
repositoryRoot = repositoryRoots.Single();
if (e.Command == VisualGitCommand.PendingChangesPullEx)
{
if (!QueryParameters(e, repositoryRoot, args))
return;
}
else
{
args.MergeStrategy = GitMergeStrategy.DefaultForBranch;
}
GitPullResult result = null;
ProgressRunnerArgs pa = new ProgressRunnerArgs();
pa.CreateLog = true;
pa.TransportClientArgs = args;
// Get a list of all documents below the specified paths that are open in editors inside VS
HybridCollection<string> lockPaths = new HybridCollection<string>(StringComparer.OrdinalIgnoreCase);
IVisualGitOpenDocumentTracker documentTracker = e.GetService<IVisualGitOpenDocumentTracker>();
foreach (string file in documentTracker.GetDocumentsBelow(repositoryRoot))
{
if (!lockPaths.Contains(file))
lockPaths.Add(file);
}
documentTracker.SaveDocuments(lockPaths); // Make sure all files are saved before merging!
using (DocumentLock lck = documentTracker.LockDocuments(lockPaths, DocumentLockType.NoReload))
using (lck.MonitorChangesForReload())
{
GitException exception = null;
e.GetService<IProgressRunner>().RunModal(CommandStrings.PullingSolution, pa,
delegate(object sender, ProgressWorkerArgs a)
{
e.GetService<IConflictHandler>().RegisterConflictHandler(args, a.Synchronizer);
try
{
a.Client.Pull(repositoryRoot, args, out result);
}
catch (GitException ex)
{
exception = ex;
}
});
if (exception != null)
{
e.GetService<IVisualGitErrorHandler>().OnWarning(exception);
}
}
}
public List<Account> GetUserList(string searchString)
{
Require.NotEmpty(searchString, nameof(searchString));
var allProjectMemberships = _projectMembershipRepostiory.GetAllProjectMemberships().ToList();
var allUsers = new HashSet<Account>(_userRepository.GetAllAccounts());
var allUsersToSearchByRole =
new HashSet<Account>(
allProjectMemberships.Select(membership => allUsers.Single(account => account.UserId == membership.DeveloperId)));
var userRolesDictionary = allUsersToSearchByRole.ToDictionary(user => user,
user =>
allProjectMemberships.Where(membership => membership.DeveloperId == user.UserId)
.Select(that => that.Role));
return userRolesDictionary.Where(
pair =>
pair.Value.Any(role => Extensions.Contains(role, searchString)))
.Select(pair => pair.Key)
.Union(
allUsers.Where(
account =>
Extensions.Contains($"{account.Firstname} {account.Lastname}",
searchString))).ToList();
}
public void HashSetExtensions_Single_ThrowsExceptionIfHashSetHasMultipleItems()
{
var set = new HashSet<Int32>() { 1, 2 };
set.Single();
}
public void HashSetExtensions_Single_ThrowsExceptionIfHashSetIsEmpty()
{
var set = new HashSet<Int32>();
set.Single();
}
private void btnDeleteCommander_Click(object sender, EventArgs e)
{
var cells = dataGridViewCommanders.SelectedCells;
HashSet<int> rowindexes = new HashSet<int>();
foreach (var cell in cells.OfType<DataGridViewCell>())
{
if (!rowindexes.Contains(cell.RowIndex))
{
rowindexes.Add(cell.RowIndex);
}
}
if (rowindexes.Count == 1)
{
var row = dataGridViewCommanders.Rows[rowindexes.Single()].DataBoundItem as EDCommander;
var result = MessageBox.Show("Do you wish to delete commander " + row.Name + "?", "Delete commander", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (result == DialogResult.Yes)
{
EDDConfig.Instance.DeleteCommander(row);
//dataGridViewCommanders.DataSource = null; // changing data source ends up, after this, screwing the column sizing..
dataGridViewCommanders.DataSource = EDDConfig.Instance.listCommanders; // can't solve it, TBD
dataGridViewCommanders.Update();
_discoveryForm.TravelControl.LoadCommandersListBox();
}
}
}
private bool ApplySuppressionFix(Func<Project, bool> shouldFixInProject, bool selectedEntriesOnly, bool isAddSuppression, bool isSuppressionInSource, bool onlyCompilerDiagnostics, bool showPreviewChangesDialog)
{
ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentDiagnosticsToFixMap = null;
ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectDiagnosticsToFixMap = null;
var title = isAddSuppression ? ServicesVSResources.SuppressMultipleOccurrences : ServicesVSResources.RemoveSuppressMultipleOccurrences;
var waitDialogMessage = isAddSuppression ? ServicesVSResources.ComputingSuppressionFix : ServicesVSResources.ComputingRemoveSuppressionFix;
// Get the diagnostics to fix from the suppression state service.
Action<CancellationToken> computeDiagnosticsToFix = cancellationToken =>
{
var diagnosticsToFix = _suppressionStateService.GetItemsAsync(
selectedEntriesOnly,
isAddSuppression,
isSuppressionInSource,
onlyCompilerDiagnostics,
cancellationToken)
.WaitAndGetResult(cancellationToken);
if (diagnosticsToFix.IsEmpty)
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
documentDiagnosticsToFixMap = GetDocumentDiagnosticsToFixAsync(diagnosticsToFix, shouldFixInProject, cancellationToken).WaitAndGetResult(cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
projectDiagnosticsToFixMap = isSuppressionInSource ?
ImmutableDictionary<Project, ImmutableArray<Diagnostic>>.Empty :
GetProjectDiagnosticsToFixAsync(diagnosticsToFix, shouldFixInProject, cancellationToken).WaitAndGetResult(cancellationToken);
};
var result = InvokeWithWaitDialog(computeDiagnosticsToFix, title, waitDialogMessage);
// Bail out if the user cancelled.
if (result == WaitIndicatorResult.Canceled ||
documentDiagnosticsToFixMap == null ||
projectDiagnosticsToFixMap == null)
{
return false;
}
if (documentDiagnosticsToFixMap.IsEmpty && projectDiagnosticsToFixMap.IsEmpty)
{
// Nothing to fix.
return true;
}
// Equivalence key determines what fix will be applied.
// Make sure we don't include any specific diagnostic ID, as we want all of the given diagnostics (which can have varied ID) to be fixed.
var equivalenceKey = isAddSuppression ?
(isSuppressionInSource ? FeaturesResources.SuppressWithPragma : FeaturesResources.SuppressWithGlobalSuppressMessage) :
FeaturesResources.RemoveSuppressionEquivalenceKeyPrefix;
// We have different suppression fixers for every language.
// So we need to group diagnostics by the containing project language and apply fixes separately.
var languages = new HashSet<string>(projectDiagnosticsToFixMap.Keys.Select(p => p.Language).Concat(documentDiagnosticsToFixMap.Select(kvp => kvp.Key.Project.Language)));
var newSolution = _workspace.CurrentSolution;
foreach (var language in languages)
{
// Use the Fix multiple occurrences service to compute a bulk suppression fix for the specified document and project diagnostics,
// show a preview changes dialog and then apply the fix to the workspace.
var documentDiagnosticsPerLanguage = GetDocumentDiagnosticsMappedToNewSolution(documentDiagnosticsToFixMap, newSolution, language);
if (!documentDiagnosticsPerLanguage.IsEmpty)
{
var suppressionFixer = GetSuppressionFixer(documentDiagnosticsPerLanguage.SelectMany(kvp => kvp.Value), language, _codeFixService);
if (suppressionFixer != null)
{
var suppressionFixAllProvider = suppressionFixer.GetFixAllProvider();
newSolution = _fixMultipleOccurencesService.GetFix(
documentDiagnosticsPerLanguage,
_workspace,
suppressionFixer,
suppressionFixAllProvider,
equivalenceKey,
title,
waitDialogMessage,
cancellationToken: CancellationToken.None);
if (newSolution == null)
{
// User cancelled or fixer threw an exception, so we just bail out.
return false;
}
}
}
var projectDiagnosticsPerLanguage = GetProjectDiagnosticsMappedToNewSolution(projectDiagnosticsToFixMap, newSolution, language);
if (!projectDiagnosticsPerLanguage.IsEmpty)
{
var suppressionFixer = GetSuppressionFixer(projectDiagnosticsPerLanguage.SelectMany(kvp => kvp.Value), language, _codeFixService);
if (suppressionFixer != null)
{
var suppressionFixAllProvider = suppressionFixer.GetFixAllProvider();
newSolution = _fixMultipleOccurencesService.GetFix(
projectDiagnosticsPerLanguage,
_workspace,
suppressionFixer,
suppressionFixAllProvider,
equivalenceKey,
title,
waitDialogMessage,
CancellationToken.None);
if (newSolution == null)
{
// User cancelled or fixer threw an exception, so we just bail out.
return false;
}
}
}
}
if (showPreviewChangesDialog)
{
newSolution = FixAllGetFixesService.PreviewChanges(
_workspace.CurrentSolution,
newSolution,
fixAllPreviewChangesTitle: title,
fixAllTopLevelHeader: title,
languageOpt: languages.Count == 1 ? languages.Single() : null,
workspace: _workspace);
if (newSolution == null)
{
return false;
}
}
waitDialogMessage = isAddSuppression ? ServicesVSResources.ApplyingSuppressionFix : ServicesVSResources.ApplyingRemoveSuppressionFix;
Action<CancellationToken> applyFix = cancellationToken =>
{
var operations = SpecializedCollections.SingletonEnumerable<CodeActionOperation>(new ApplyChangesOperation(newSolution));
_editHandlerService.Apply(
_workspace,
fromDocument: null,
operations: operations,
title: title,
cancellationToken: cancellationToken);
};
result = InvokeWithWaitDialog(applyFix, title, waitDialogMessage);
return result == WaitIndicatorResult.Completed;
}
public void HashSetExtensions_Single_ReturnsSingleItemInHashSet()
{
var set = new HashSet<Int32>() { 4 };
var result = set.Single();
TheResultingValue(result).ShouldBe(4);
}
private int lua_RequestStatic(string path, Type typ, string methodname)
{
MethodInfo[] allmethods = typ.GetMethods(BindingFlags.Static | BindingFlags.Public);
HashSet<MethodInfo> candidates = new HashSet<MethodInfo>();
foreach (MethodInfo method in allmethods)
{
if (method.Name == methodname)
candidates.Add(method);
}
if (candidates.Count == 0)
{
Logger.Error(string.Format("Failed to locate static method {0} on type {1}!", methodname, typ));
return 0;
}
else
if (candidates.Count == 1)
{
lua.RegisterFunction(path, null, candidates.Single());
return 1;
}
else
{
// Lets filter out any methods that use generic, in or out params
var filtered = candidates.Where((x) =>
{
if (x.IsGenericMethod || x.ContainsGenericParameters) return false;
foreach (ParameterInfo pinfo in x.GetParameters())
{
if (!pinfo.IsRetval)
{
if (pinfo.IsOut) return false;
if (pinfo.IsIn) return false;
}
}
return true;
}).ToArray();
if (filtered.Length == 1)
{
lua.RegisterFunction(path, null, filtered[0]);
return 1;
}
else
{
//LogError(string.Format("Failed to locate suitable static method {0} on type {1}! (there were {2} candidates)", methodname, typ, filtered.Length));
/*for (int i = 0; i < filtered.Length; i++)
lua[path + "_Overload" + i.ToString()] = filtered[i];*/
lua[path] = filtered;
return filtered.Length;
}
}
}
public void HashSetExtensions_Single_ThrowsExceptionIfHashSetHasMultipleItems()
{
var set = new HashSet<Int32>() { 1, 2 };
Assert.That(() => set.Single(),
Throws.TypeOf<InvalidOperationException>());
}
private static NotSupportedException InvalidCompiledQueryParameterException(Expression expression)
{
ParameterExpression parameterExp;
if (expression.NodeType == ExpressionType.Parameter)
{
parameterExp = (ParameterExpression)expression;
}
else
{
// If this is a simple query parameter (involving a single delegate parameter) report the
// type of that parameter. Otherwise, report the type of the part of the parameter.
HashSet<ParameterExpression> parameters = new HashSet<ParameterExpression>();
EntityExpressionVisitor.Visit(expression, (exp, baseVisit) =>
{
if (null != exp && exp.NodeType == ExpressionType.Parameter)
{
parameters.Add((ParameterExpression)exp);
}
return baseVisit(exp);
});
if (parameters.Count != 1)
{
return EntityUtil.NotSupported(Strings.CompiledELinq_UnsupportedParameterTypes(expression.Type.FullName));
}
parameterExp = parameters.Single();
}
if (parameterExp.Type.Equals(expression.Type))
{
// If the expression type is the same as the parameter type, indicate that the parameter type is not valid.
return EntityUtil.NotSupported(Strings.CompiledELinq_UnsupportedNamedParameterType(parameterExp.Name, parameterExp.Type.FullName));
}
else
{
// Otherwise, indicate that using the specified parameter to produce a value of the expression's type is not supported in compiled query
return EntityUtil.NotSupported(Strings.CompiledELinq_UnsupportedNamedParameterUseAsType(parameterExp.Name, expression.Type.FullName));
}
}
public void HashSetExtensions_Single_ThrowsExceptionIfHashSetIsEmpty()
{
var set = new HashSet<Int32>();
Assert.That(() => set.Single(),
Throws.TypeOf<InvalidOperationException>());
}
