public TfsInfo(SolutionState state, string sol, string branch, string workspace)
{
if (state == SolutionState.Error)
{
throw new ArgumentOutOfRangeException("state", "A SolutionState of Error requires passing in the Exception");
}
this.State = state;
this.SolutionFileName = sol;
this.BranchLocation = branch;
this.WorkspaceName = workspace;
}
public void Find(
SolutionState state,
HashSet <Checksum> searchingChecksumsLeft,
Dictionary <Checksum, object> result,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// verify input
Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksum));
Contract.ThrowIfFalse(this == stateChecksum);
if (searchingChecksumsLeft.Remove(Checksum))
{
result[Checksum] = this;
}
if (searchingChecksumsLeft.Remove(Info))
{
result[Info] = state.SolutionInfo.Attributes;
}
if (searchingChecksumsLeft.Remove(Projects.Checksum))
{
result[Projects.Checksum] = Projects;
}
foreach (var kv in state.ProjectStates)
{
var projectState = kv.Value;
// solution state checksum can't be created without project state checksums created first
Contract.ThrowIfFalse(projectState.TryGetStateChecksums(out var projectStateChecksums));
projectStateChecksums.Find(projectState, searchingChecksumsLeft, result, cancellationToken);
if (searchingChecksumsLeft.Count == 0)
{
return;
}
}
}
// Hub API
public async Task <bool> UpdateInLock(int solutionId, SolutionState stateId)
{
var slock = await _db.SolutionLocks.FindAsync(solutionId);
// 未被锁住，或者锁住的客户端不正确，或者锁已经过期，则不允许操作。
if (slock == null || slock.LockClientId != Guid.Parse(Context.ConnectionId) || slock.LockEndTime < DateTime.Now)
{
return(false);
}
// 锁住，允许操作。
var solution = await _db.Solutions.FindAsync(solutionId);
solution.State = stateId;
// 保存数据。
_db.Entry(solution).State = EntityState.Modified;
await _db.SaveChangesAsync();
SolutionHub.PushChange(solution.Id, solution.State, 0, 0.0f);
return(true);
}
public Storage(SolutionState solutionState)
{
SolutionState = solutionState;
_serializer = SolutionState.Workspace.Services.GetRequiredService <ISerializerService>();
}
public async Task FindAsync(
SolutionState state,
HashSet <Checksum> searchingChecksumsLeft,
Dictionary <Checksum, object> result,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// verify input
Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksum));
Contract.ThrowIfFalse(this == stateChecksum);
if (searchingChecksumsLeft.Remove(Checksum))
{
result[Checksum] = this;
}
if (searchingChecksumsLeft.Remove(Attributes))
{
result[Attributes] = state.SolutionAttributes;
}
if (searchingChecksumsLeft.Remove(Options))
{
result[Options] = state.Options;
}
if (searchingChecksumsLeft.Remove(FrozenSourceGeneratedDocumentIdentity))
{
Contract.ThrowIfNull(state.FrozenSourceGeneratedDocumentState, "We should not have had a FrozenSourceGeneratedDocumentIdentity checksum if we didn't have a text in the first place.");
result[FrozenSourceGeneratedDocumentIdentity] = state.FrozenSourceGeneratedDocumentState.Identity;
}
if (searchingChecksumsLeft.Remove(FrozenSourceGeneratedDocumentText))
{
Contract.ThrowIfNull(state.FrozenSourceGeneratedDocumentState, "We should not have had a FrozenSourceGeneratedDocumentState checksum if we didn't have a text in the first place.");
result[FrozenSourceGeneratedDocumentText] = await SerializableSourceText.FromTextDocumentStateAsync(state.FrozenSourceGeneratedDocumentState, cancellationToken).ConfigureAwait(false);
}
if (searchingChecksumsLeft.Remove(Projects.Checksum))
{
result[Projects.Checksum] = Projects;
}
if (searchingChecksumsLeft.Remove(AnalyzerReferences.Checksum))
{
result[AnalyzerReferences.Checksum] = AnalyzerReferences;
}
foreach (var(_, projectState) in state.ProjectStates)
{
// solution state checksum can't be created without project state checksums created first
// check unsupported projects
if (!projectState.TryGetStateChecksums(out var projectStateChecksums))
{
Contract.ThrowIfTrue(RemoteSupportedLanguages.IsSupported(projectState.Language));
continue;
}
await projectStateChecksums.FindAsync(projectState, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
if (searchingChecksumsLeft.Count == 0)
{
break;
}
}
ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, result, cancellationToken);
}
public Storage CreateStorage(SolutionState solutionState)
{
return(new Storage(solutionState));
}
public static ProjectKey ToProjectKey(SolutionState solutionState, ProjectState projectState) => new(SolutionKey.ToSolutionKey(solutionState), projectState.Id, projectState.FilePath, projectState.Name, projectState.GetParseOptionsChecksum());
/// <summary>
/// BFS algorithm
/// </summary>
/// <param name="map"></param>
public SolutionState Solve_BFS()
{
var beginState = GetStartingState();
if (beginState.IsFinished())
{
return(new SolutionState(beginState, 0, 0, 0, 0));
}
HashSet <StateHash> allUniqueStates = new HashSet <StateHash>();
allUniqueStates.Add(beginState.Hash);
Queue <GameState> frontStates = new Queue <GameState>(32000);
frontStates.Enqueue(beginState);
int iterations = 0;
int maxFrontStatesCount = 0;
var sw = Stopwatch.StartNew();
GameState currentState = null;
Func <StateHash, bool> checkHash = (hash) =>
{
return(allUniqueStates.Contains(hash) == false);
};
Func <GameState, Direction, bool> f = (state, dir) =>
{
GameState newState = GetNewState(state, dir, checkHash);
if (newState != null)
{
if (newState.IsFinished())
{
currentState = newState;
return(true);
}
allUniqueStates.Add(newState.Hash);
//if ( ( Symmetry & eMapSymmetry.Horizontal ) == eMapSymmetry.Horizontal )
// allUniqueStates.Add( GetHashForSymmetricState( newState, 1, 0 ) );
//if ( ( Symmetry & eMapSymmetry.Vertical ) == eMapSymmetry.Vertical )
// allUniqueStates.Add( GetHashForSymmetricState( newState, 0, 1 ) );
//if ( ( Symmetry & eMapSymmetry.Both ) == eMapSymmetry.Both )
// allUniqueStates.Add( GetHashForSymmetricState( newState, 1, 1 ) );
frontStates.Enqueue(newState);
}
return(false);
};
while (frontStates.Count > 0)
{
currentState = frontStates.Dequeue();
if (f(currentState, Direction.Left))
{
break;
}
if (f(currentState, Direction.Up))
{
break;
}
if (f(currentState, Direction.Right))
{
break;
}
if (f(currentState, Direction.Down))
{
break;
}
iterations++;
maxFrontStatesCount = Math.Max(maxFrontStatesCount, frontStates.Count());
}
SolutionState solution = new SolutionState(currentState, elapsedTime: (int)(sw.ElapsedMilliseconds),
iterationsCount: iterations,
maxFrontStatesCount: maxFrontStatesCount,
uniquesStatesCount: allUniqueStates.Count);
return(solution);
}
private void ReadSolutionInfo()
{
SolutionState state = SolutionState.NoSolution;
string workspaceName = string.Empty;
string branchLocation = string.Empty;
string solutionFile = string.Empty;
string errorMessage = string.Empty;
Solution4 sol = (Solution4)_dte2.Solution;
try
{
if (sol.IsOpen == false)
{
state = SolutionState.NoSolution;
_trace.TraceEvent(TraceEventType.Verbose, 0, "No Solution Opened");
}
else
{
solutionFile = sol.FileName;
_trace.TraceEvent(TraceEventType.Information, 0, "Opened Solution: {0}", sol.FullName);
if (_vcExt == null)
{
_trace.TraceEvent(TraceEventType.Information, 0, "No TFS object");
state = SolutionState.TfsNotPresent;
}
else if (_vcExt.SolutionWorkspace == null)
{
_trace.TraceEvent(TraceEventType.Information, 0, "No TFS Workspace for this Solution ");
state = SolutionState.NotInTfs;
}
else
{
VersionControlServer vcServer = _vcExt.SolutionWorkspace.VersionControlServer;
_trace.TraceEvent(TraceEventType.Verbose, 0, "Connected to TFS Collection: {0}", vcServer.TeamProjectCollection.Name);
// find out where the TFS info is.
string serverSol = _vcExt.SolutionWorkspace.GetServerItemForLocalItem(sol.FullName);
if (string.IsNullOrEmpty(serverSol) == true)
{
_trace.TraceEvent(TraceEventType.Warning, 0, "Solution file is NOT in TFS");
state = SolutionState.NotInTfs;
}
else
{
workspaceName = _vcExt.SolutionWorkspace.Name;
branchLocation = TfsHelpers.GetBranchLocationForItem(vcServer, serverSol);
_trace.TraceEvent(TraceEventType.Information, 0, "Solution is in Branch: {0}", branchLocation);
state = SolutionState.InTfs;
}
}
}
}
catch (Exception ex)
{
state = SolutionState.Error;
_infoService.CurrentSolutionInfo = new TfsInfo(ex);
}
if (state != SolutionState.Error)
{
_infoService.CurrentSolutionInfo = new TfsInfo(state, solutionFile, branchLocation, workspaceName);
}
}
public static SolutionKey ToSolutionKey(SolutionState solutionState) =>
public RootTreeNode(ChecksumTreeCollection owner, SolutionState solutionState) :
base(owner, GetOrCreateSerializer(solutionState.Workspace.Services))
{
SolutionState = solutionState;
}
public Storage(AssetStorages owner, SolutionState solutionState)
{
SolutionState = solutionState;
_serializer = new Serializer(SolutionState.Workspace.Services);
}
public IRootChecksumTreeNode CreateRootTreeNode(SolutionState solutionState)
{
return new RootTreeNode(this, solutionState);
}
public Storage(SolutionState solutionState)
{
SolutionState = solutionState;
_serializer = new Serializer(SolutionState.Workspace);
}
public static ProjectKey ToProjectKey(
SolutionState solutionState,
ProjectState projectState
) =>
public Task <SolutionChecksumObject> BuildAsync(SolutionState solutionState, CancellationToken cancellationToken)
{
return(_checksumTree.GetOrCreateChecksumObjectWithChildrenAsync(solutionState, solutionState, SolutionChecksumObject.Name, CreateSolutionChecksumObjectAsync, cancellationToken));
}
public IRootChecksumTreeNode CreateRootTreeNode(SolutionState solutionState)
{
return(new RootTreeNode(this, solutionState));
}
private SolutionChecksumObjectInfo GetInfo(SolutionState solutionState)
{
return(new SolutionChecksumObjectInfo(solutionState.Id, solutionState.Version, solutionState.FilePath));
}
public Storage CreateStorage(SolutionState solutionState) => new Storage(solutionState);
public Task <Asset> BuildAsync(SolutionState solutionState, CancellationToken cancellationToken)
{
return(_checksumTree.GetOrCreateAssetAsync(solutionState, GetInfo(solutionState), WellKnownChecksumObjects.SolutionChecksumObjectInfo, CreateSolutionChecksumObjectInfoAsync, cancellationToken));
}
public static ProjectKey ToProjectKey(SolutionState solutionState, ProjectState projectState) => ToProjectKey(SolutionKey.ToSolutionKey(solutionState), projectState);
public static SolutionKey ToSolutionKey(SolutionState solutionState) => new(solutionState.Id, solutionState.FilePath);
protected AbstractFormatterTest()
{
TestState = new SolutionState(DefaultFolderPath + DefaultFilePathPrefix, DefaultFileExt);
}
public static ProjectKey ToProjectKey(SolutionState solutionState, ProjectState projectState) => new((SolutionKey)solutionState, projectState.Id, projectState.FilePath, projectState.Name);
public async Task FindAsync(
SolutionState state,
HashSet <Checksum> searchingChecksumsLeft,
Dictionary <Checksum, object> result,
CancellationToken cancellationToken
)
{
cancellationToken.ThrowIfCancellationRequested();
// verify input
Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksum));
Contract.ThrowIfFalse(this == stateChecksum);
if (searchingChecksumsLeft.Remove(Checksum))
{
result[Checksum] = this;
}
if (searchingChecksumsLeft.Remove(Attributes))
{
result[Attributes] = state.SolutionAttributes;
}
if (searchingChecksumsLeft.Remove(Options))
{
result[Options] = state.Options;
}
if (searchingChecksumsLeft.Remove(Projects.Checksum))
{
result[Projects.Checksum] = Projects;
}
if (searchingChecksumsLeft.Remove(AnalyzerReferences.Checksum))
{
result[AnalyzerReferences.Checksum] = AnalyzerReferences;
}
foreach (var(_, projectState) in state.ProjectStates)
{
// solution state checksum can't be created without project state checksums created first
// check unsupported projects
if (!projectState.TryGetStateChecksums(out var projectStateChecksums))
{
Contract.ThrowIfTrue(
RemoteSupportedLanguages.IsSupported(projectState.Language)
);
continue;
}
await projectStateChecksums
.FindAsync(projectState, searchingChecksumsLeft, result, cancellationToken)
.ConfigureAwait(false);
if (searchingChecksumsLeft.Count == 0)
{
break;
}
}
ChecksumCollection.Find(
state.AnalyzerReferences,
AnalyzerReferences,
searchingChecksumsLeft,
result,
cancellationToken
);
}
//===================================================================== FUNCTION
public void Solve()
{
// store number of changes
int changes = 0;
// iterate through grid
do
{
changes = 0;
foreach (bool isX in new bool[] { true, false })
{
int dimensionLength = (isX ? Height : Width);
for (int lineID = 0; lineID < dimensionLength; lineID++)
{
int[] clue = GetClue(lineID, isX);
SolutionLine line = ReadSolutionLine(lineID, isX);
SolutionState[] items = new SolutionState[line.Items.Length];
Array.Copy(line.Items, items, line.Items.Length);
line.Solve();
for (int i = 0; i < items.Length; i++)
{
if (items[i] != line.Items[i]) changes++;
}
WriteSolutionLine(line);
}
}
//Console.WriteLine(changes);
}
while (changes > 0);
}
public UnitTestingSolutionStateWrapper(SolutionState underlyingObject) => UnderlyingObject = underlyingObject ?? throw new ArgumentNullException(nameof(underlyingObject));
//===================================================================== INITIALIZE
public SolutionLine(int[] clue, SolutionState[] line, int lineID, bool isX)
{
Clue = clue;
Items = line;
LineID = lineID;
IsX = isX;
}
public SolutionChecksumFinder(SolutionState state, ISerializerService serializer, CancellationToken cancellationToken) : this()
{
_state = state;
_serializer = serializer;
_cancellationToken = cancellationToken;
}
private int GetGroupSizeFromID(int id, SolutionState groupState)
{
if (Items[id] != groupState) return 0;
else return GetGroupEndFromID(id) - GetGroupStartFromID(id) + 1;
}
public async Task UpdateSolutionStateAsync(long solutionId, SolutionState newState)
{
await UpdateAsync(solutionId, solution => new Solution {
State = newState
});
}
private int GetStateCount(SolutionState state)
{
return Items.Count(isTrue => isTrue == state);
}
private async Task <SolutionChecksumObject> CreateSolutionChecksumObjectAsync(SolutionState key, SolutionState solutionState, string kind, CancellationToken cancellationToken)
{
var assetBuilder = new AssetBuilder(_checksumTree);
var info = assetBuilder.Build(solutionState, cancellationToken);
var subTreeNode = _checksumTree.GetOrCreateSubTreeNode(key);
var subSnapshotBuilder = new ChecksumTreeBuilder(subTreeNode);
var projects = await subSnapshotBuilder.BuildAsync(solutionState.ProjectStates, solutionState.ProjectIds.Select(id => solutionState.ProjectStates[id]), cancellationToken).ConfigureAwait(false);
return(new SolutionChecksumObject(_serializer, info.Checksum, projects));
}
private int GetStateCount(SolutionState state, int start, int end)
{
int count = 0;
for (int i = start; i <= end; i++) if (Items[i] == state) count++;
return count;
}
public static SolutionKey ToSolutionKey(SolutionState solutionState) => new(solutionState.Workspace.Kind, solutionState.Id, solutionState.FilePath, solutionState.BranchId == solutionState.Workspace.PrimaryBranchId);
private bool IsGroupAtID(int id, SolutionState groupState, SolutionState surroundState)
{
// out of bounds returns true as legal surround state
if (Items[id] != groupState) return false;
int start = GetGroupStartFromID(id), end = GetGroupEndFromID(id);
bool leftTrue = false, rightTrue = false;
leftTrue = (IsOutsideBounds(start - 1) || Items[start - 1] == surroundState);
rightTrue = (IsOutsideBounds(end + 1) || Items[end + 1] == surroundState);
return leftTrue && rightTrue;
}
protected AbstractFormatterTest()
{
TestState = new SolutionState("Test", Language, DefaultFilePathPrefix, DefaultFileExt);
}
private void ModifyState(SolutionState state, int start, int count)
{
try
{
for (int cnt = 0; cnt < count; cnt++) Items[start + cnt] = state;
}
catch (Exception e)
{
Console.WriteLine(new System.Diagnostics.StackFrame(1).GetMethod().Name + ": " + state.ToString() + ", " + start + ", " + count);
}
}
public Storage CreateStorage(SolutionState solutionState)
{
return new Storage(this, solutionState);
}
private SolutionLine ReadSolutionLine(int[] clue, int start, int end)
{
int length = end - start + 1;
SolutionState[] subLine = new SolutionState[length];
for (int i = start; i <= end; i++) subLine[i - start] = Items[i];
return new SolutionLine(clue, subLine, start, IsX);
}
public SolutionLine ReadSolutionLine(int lineID, bool isX)
{
int[] clue;
SolutionState[] line;
if (isX)
{
clue = _cluesX[lineID];
line = new SolutionState[Height];
for (int y = 0; y < Height; y++) line[y] = _solution[lineID, y];
}
else
{
clue = _cluesY[lineID];
line = new SolutionState[Width];
for (int x = 0; x < Width; x++) line[x] = _solution[x, lineID];
}
return new SolutionLine(clue, line, lineID, isX);
}
public async Task FindAsync(
SolutionState state,
HashSet <Checksum> searchingChecksumsLeft,
Dictionary <Checksum, object> result,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (searchingChecksumsLeft.Count == 0)
{
return;
}
// verify input
if (searchingChecksumsLeft.Remove(Checksum))
{
result[Checksum] = this;
}
if (searchingChecksumsLeft.Remove(Attributes))
{
result[Attributes] = state.SolutionAttributes;
}
if (searchingChecksumsLeft.Remove(FrozenSourceGeneratedDocumentIdentity))
{
Contract.ThrowIfNull(state.FrozenSourceGeneratedDocumentState, "We should not have had a FrozenSourceGeneratedDocumentIdentity checksum if we didn't have a text in the first place.");
result[FrozenSourceGeneratedDocumentIdentity] = state.FrozenSourceGeneratedDocumentState.Identity;
}
if (searchingChecksumsLeft.Remove(FrozenSourceGeneratedDocumentText))
{
Contract.ThrowIfNull(state.FrozenSourceGeneratedDocumentState, "We should not have had a FrozenSourceGeneratedDocumentState checksum if we didn't have a text in the first place.");
result[FrozenSourceGeneratedDocumentText] = await SerializableSourceText.FromTextDocumentStateAsync(state.FrozenSourceGeneratedDocumentState, cancellationToken).ConfigureAwait(false);
}
if (searchingChecksumsLeft.Remove(Projects.Checksum))
{
result[Projects.Checksum] = Projects;
}
if (searchingChecksumsLeft.Remove(AnalyzerReferences.Checksum))
{
result[AnalyzerReferences.Checksum] = AnalyzerReferences;
}
foreach (var(_, projectState) in state.ProjectStates)
{
if (searchingChecksumsLeft.Count == 0)
{
break;
}
// It's possible not all all our projects have checksums. Specifically, we may have only been
// asked to compute the checksum tree for a subset of projects that were all that a feature needed.
if (projectState.TryGetStateChecksums(out var projectStateChecksums))
{
await projectStateChecksums.FindAsync(projectState, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
}
}
ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, result, cancellationToken);
}
