void SetState(GitItemState set, GitItemState unset)
{
// NOTE: This method is /not/ thread safe, but its callers have race conditions anyway
// Setting an integer could worst case completely destroy the integer; nothing a refresh can't fix
GitItemState st = (_currentState & ~unset) | set;
if (st != _currentState)
{
// Calculate whether we have a change or just new information
bool changed = (st & _onceValid & NoBroadcastFor) != (_currentState & _onceValid & NoBroadcastFor);
if (changed && !_enqueued)
{
_enqueued = true;
// Schedule a stat changed broadcast
lock (_stateChanged)
{
_stateChanged.Enqueue(this);
ScheduleUpdateNotify();
}
}
_currentState = st;
}
_validState |= (set | unset);
_onceValid |= _validState;
}
private void RefreshTo(GitStatusData status)
{
_cookie = NextCookie();
_statusDirty = XBool.False;
_status = status;
GitItemState set = GitItemState.None;
GitItemState unset = GitItemState.None;
if (status.IsConflicted)
set |= GitItemState.Conflicted;
else
unset |= GitItemState.Conflicted;
if (status.IsIgnored)
{
set |= GitItemState.Versionable | GitItemState.Exists;
unset |= GitItemState.Added | GitItemState.Deleted | GitItemState.Modified | GitItemState.Ignored | GitItemState.GitDirty | GitItemState.Versioned;
}
else if (MaxModified(status.IndexStatus) && MaxModified(status.WorkingStatus))
{
// We don't know if the node is a file or directory yet
set |= GitItemState.Versioned | GitItemState.Versionable | GitItemState.Exists;
unset |= GitItemState.Added | GitItemState.Deleted | GitItemState.Ignored;
if (status.Modified)
set |= GitItemState.GitDirty | GitItemState.Modified;
else
unset |= GitItemState.GitDirty | GitItemState.Modified;
}
else if (status.IndexStatus == GitStatus.New || status.WorkingStatus == GitStatus.New)
{
set |= GitItemState.Versioned | GitItemState.Versionable | GitItemState.Exists | GitItemState.Added;
unset |= GitItemState.Deleted | GitItemState.Modified | GitItemState.Ignored | GitItemState.GitDirty;
}
else if (status.IndexStatus == GitStatus.Deleted || status.WorkingStatus == GitStatus.Deleted)
{
set |= GitItemState.Versioned | GitItemState.Versionable | GitItemState.Exists | GitItemState.Deleted;
unset |= GitItemState.Deleted | GitItemState.Modified | GitItemState.Ignored | GitItemState.GitDirty;
}
else
{
throw new NotImplementedException();
}
switch(status.NodeKind)
{
case SvnNodeKind.File:
set |= GitItemState.IsDiskFile;
unset |= GitItemState.IsDiskFolder;
break;
case SvnNodeKind.Directory:
set |= GitItemState.IsDiskFolder;
unset |= GitItemState.IsDiskFile;
break;
}
SetState(set, unset);
}
private void RefreshTo(NoSccStatus status, SvnNodeKind nodeKind)
{
_cookie = NextCookie();
_statusDirty = XBool.False;
GitItemState set = GitItemState.None;
GitItemState unset = GitItemState.Modified | GitItemState.Added
| GitItemState.Deleted | GitItemState.Conflicted | GitItemState.Ignored | GitItemState.Versioned | GitItemState.IsWCRoot | GitItemState.GitDirty | GitItemState.Ignored;
switch (status)
{
case NoSccStatus.NotExisting:
SetState(set, GitItemState.Exists | GitItemState.ReadOnly | GitItemState.IsDiskFile | GitItemState.IsDiskFolder | GitItemState.Versionable | unset);
_status = GitStatusData.NotExisting;
break;
case NoSccStatus.NotVersionable:
unset |= GitItemState.Versionable;
goto case NoSccStatus.NotVersioned; // fall through
case NoSccStatus.NotVersioned:
SetState(GitItemState.Exists | set, GitItemState.None | unset);
_status = GitStatusData.NotVersioned;
break;
case NoSccStatus.Unknown:
default:
SetDirty(set | unset);
_statusDirty = XBool.True;
break;
}
//InitializeFromKind(nodeKind);
}
private void SetDirty(GitItemState dirty)
{
// NOTE: This method is /not/ thread safe, but its callers have race conditions anyway
// Setting an integer could worst case completely destroy the integer; nothing a refresh can't fix
_validState &= ~dirty;
}
bool TryGetState(GitItemState mask, out GitItemState result)
{
if ((mask & _validState) != mask)
{
result = GitItemState.None;
return false;
}
result = _currentState & mask;
return true;
}
void IGitItemUpdate.RefreshTo(GitItem lead)
{
if (lead == null)
throw new ArgumentNullException("lead");
else if (lead._status == null)
throw new InvalidOperationException("Lead status = null");
_status = lead._status;
_statusDirty = lead._statusDirty;
GitItemState current = lead._currentState;
GitItemState valid = lead._validState;
SetState(current & valid, (~current) & valid);
_ticked = false;
_modified = lead._modified;
_cookie = NextCookie(); // Status 100% the same, but changed... Cookies are free ;)
}
void UpdateAttributeInfo()
{
// One call of the kernel's GetFileAttributesW() gives us most info we need
uint value = NativeMethods.GetFileAttributes(FullPath);
if (value == NativeMethods.INVALID_FILE_ATTRIBUTES)
{
// File does not exist / no rights, etc.
SetState(GitItemState.None,
GitItemState.Exists | GitItemState.ReadOnly | GitItemState.Versionable | GitItemState.IsDiskFolder | GitItemState.IsDiskFile);
return;
}
GitItemState set = GitItemState.Exists;
GitItemState unset = GitItemState.None;
if ((value & NativeMethods.FILE_ATTRIBUTE_READONLY) != 0)
{
set |= GitItemState.ReadOnly;
}
else
{
unset = GitItemState.ReadOnly;
}
if ((value & NativeMethods.FILE_ATTRIBUTE_DIRECTORY) != 0)
{
unset |= GitItemState.IsDiskFile | GitItemState.ReadOnly;
set = GitItemState.IsDiskFolder | (set & ~GitItemState.ReadOnly); // Don't set readonly
}
else
{
set |= GitItemState.IsDiskFile;
unset |= GitItemState.IsDiskFolder;
}
SetState(set, unset);
}
public GitItemState GetState(GitItemState flagsToGet)
{
GitItemState unavailable = flagsToGet & ~_validState;
if (unavailable == 0)
return _currentState & flagsToGet; // We have everything we need
if (0 != (unavailable & MaskRefreshTo))
{
Debug.Assert(_statusDirty != XBool.False);
RefreshStatus();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskRefreshTo) == 0, "RefreshMe() set all attributes it should");
}
if (0 != (unavailable & MaskGetAttributes))
{
UpdateAttributeInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskGetAttributes) == 0, "UpdateAttributeInfo() set all attributes it should");
}
if (0 != (unavailable & MaskUpdateSolution))
{
UpdateSolutionInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskUpdateSolution) == 0, "UpdateSolution() set all attributes it should");
}
if (0 != (unavailable & MaskDocumentInfo))
{
UpdateDocumentInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskDocumentInfo) == 0, "UpdateDocumentInfo() set all attributes it should");
}
if (0 != (unavailable & MaskVersionable))
{
UpdateVersionable();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskVersionable) == 0, "UpdateVersionable() set all attributes it should");
}
if (0 != (unavailable & MaskTextFile))
{
UpdateTextFile();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskTextFile) == 0, "UpdateTextFile() set all attributes it should");
}
if (0 != (unavailable & MaskIsAdministrativeArea))
{
UpdateAdministrativeArea();
unavailable = flagsToGet &~_validState;
Debug.Assert((~_validState & MaskIsAdministrativeArea) == 0, "UpdateIsAdministrativeArea() set all attributes it should");
}
if (unavailable != 0)
{
Trace.WriteLine(string.Format("Don't know how to retrieve {0:X} state; clearing dirty flag", (int)unavailable));
_validState |= unavailable;
}
return _currentState & flagsToGet;
}
void SetState(GitItemState set, GitItemState unset)
{
// NOTE: This method is /not/ thread safe, but its callers have race conditions anyway
// Setting an integer could worst case completely destroy the integer; nothing a refresh can't fix
GitItemState st = (_currentState & ~unset) | set;
if (st != _currentState)
{
// Calculate whether we have a change or just new information
bool changed = (st & _onceValid & NoBroadcastFor) != (_currentState & _onceValid & NoBroadcastFor);
if (changed && !_enqueued)
{
_enqueued = true;
// Schedule a stat changed broadcast
lock (_stateChanged)
{
_stateChanged.Enqueue(this);
ScheduleUpdateNotify();
}
}
_currentState = st;
}
_validState |= (set | unset);
_onceValid |= _validState;
}
private void SetDirty(GitItemState dirty)
{
// NOTE: This method is /not/ thread safe, but its callers have race conditions anyway
// Setting an integer could worst case completely destroy the integer; nothing a refresh can't fix
_validState &= ~dirty;
}
bool IGitItemUpdate.TryGetState(GitItemState get, out GitItemState value)
{
return TryGetState(get, out value);
}
void IGitItemUpdate.SetState(GitItemState set, GitItemState unset)
{
SetState(set, unset);
}
void IGitItemUpdate.SetDirty(GitItemState dirty)
{
SetDirty(dirty);
}
void IGitItemUpdate.SetState(GitItemState set, GitItemState unset)
{
SetState(set, unset);
}
void IGitItemUpdate.SetDirty(GitItemState dirty)
{
SetDirty(dirty);
}
bool IGitItemUpdate.TryGetState(GitItemState get, out GitItemState value)
{
return(TryGetState(get, out value));
}
public GitItemState GetState(GitItemState flagsToGet)
{
GitItemState unavailable = flagsToGet & ~_validState;
if (unavailable == 0)
{
return(_currentState & flagsToGet); // We have everything we need
}
if (0 != (unavailable & MaskRefreshTo))
{
Debug.Assert(_statusDirty != XBool.False);
RefreshStatus();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskRefreshTo) == 0, "RefreshMe() set all attributes it should");
}
if (0 != (unavailable & MaskGetAttributes))
{
UpdateAttributeInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskGetAttributes) == 0, "UpdateAttributeInfo() set all attributes it should");
}
if (0 != (unavailable & MaskUpdateSolution))
{
UpdateSolutionInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskUpdateSolution) == 0, "UpdateSolution() set all attributes it should");
}
if (0 != (unavailable & MaskDocumentInfo))
{
UpdateDocumentInfo();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskDocumentInfo) == 0, "UpdateDocumentInfo() set all attributes it should");
}
/*if (0 != (unavailable & MaskVersionable))
* {
* UpdateVersionable();
*
* unavailable = flagsToGet & ~_validState;
*
* Debug.Assert((~_validState & MaskVersionable) == 0, "UpdateVersionable() set all attributes it should");
* }
*
* if (0 != (unavailable & MaskMustLock))
* {
* UpdateMustLock();
*
* unavailable = flagsToGet & ~_validState;
*
* Debug.Assert((~_validState & MaskMustLock) == 0, "UpdateMustLock() set all attributes it should");
* }
*
* if (0 != (unavailable & MaskTextFile))
* {
* UpdateTextFile();
*
* unavailable = flagsToGet & ~_validState;
*
* Debug.Assert((~_validState & MaskTextFile) == 0, "UpdateTextFile() set all attributes it should");
* }*/
if (0 != (unavailable & MaskWCRoot))
{
UpdateWCRoot();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskWCRoot) == 0, "UpdateWCRoot() set all attributes it should");
}
if (0 != (unavailable & MaskIsAdministrativeArea))
{
UpdateAdministrativeArea();
unavailable = flagsToGet & ~_validState;
Debug.Assert((~_validState & MaskIsAdministrativeArea) == 0, "UpdateIsAdministrativeArea() set all attributes it should");
}
/*if (unavailable != 0)
* {
* Trace.WriteLine(string.Format("Don't know how to retrieve {0:X} state; clearing dirty flag", (int)unavailable));
*
* _validState |= unavailable;
* }*/
return(_currentState & flagsToGet);
}
