CLogChangedPath::CLogChangedPath
( const CRevisionInfoContainer::CChangesIterator& iter
, const CDictionaryBasedTempPath& logPath)
: path (iter.GetPath())
, copyFromPath (NULL, (index_t)NO_INDEX)
, copyFromRev (0)
{
flags.nodeKind = static_cast<svn_node_kind_t>(iter->GetPathType());
flags.action = (DWORD)iter.GetAction() / 4;
flags.textModifies = static_cast<svn_tristate_t>(iter->GetTextModifies());
flags.propsModifies = static_cast<svn_tristate_t>(iter->GetPropsModifies());
// check relevance for log path
flags.relevantForStartPath = logPath.IsSameOrParentOf (path)
|| logPath.IsSameOrChildOf (path);
// set copy-from info, if available
if (iter.HasFromPath() && (iter.GetFromRevision() != NO_REVISION))
{
copyFromPath = iter.GetFromPath();
copyFromRev = iter.GetFromRevision();
}
}
bool CLogIteratorBase::ContainsCopyOrDelete
( const CRevisionInfoContainer::CChangesIterator& first
, const CRevisionInfoContainer::CChangesIterator& last)
{
// close examination of all changes
for (CRevisionInfoContainer::CChangesIterator iter = first
; iter != last
; ++iter)
{
// the only non-critical operation is the mere modification
CRevisionInfoContainer::TChangeAction action = iter.GetAction();
if (action != CRevisionInfoContainer::ACTION_CHANGED)
return true;
}
// no copy / delete / replace found
return false;
}
bool CLogIteratorBase::PathInRevision
( const CRevisionInfoContainer::CChangesIterator& first
, const CRevisionInfoContainer::CChangesIterator& last
, const CDictionaryBasedTempPath& path)
{
// close examination of all changes
for ( CRevisionInfoContainer::CChangesIterator iter = first
; iter != last
; ++iter)
{
// if (and only if) path is a cached path,
// it may be a parent of the changedPath
// (i.e. report a change of this or some sub-path)
CDictionaryBasedPath changedPath = iter->GetPath();
if ( path.IsFullyCachedPath()
&& path.GetBasePath().IsSameOrParentOf (changedPath))
return true;
// this change affects a true parent path or completely unrelated path
// -> ignore mere modifications (e.g. properties on a folder)
if (iter->GetAction() == CRevisionInfoContainer::ACTION_CHANGED)
continue;
// this is an add / delete / replace.
// does it affect our path?
if (changedPath.IsSameOrParentOf (path.GetBasePath()))
return true;
}
// no paths that we were looking for
return false;
}
bool CLogIteratorBase::InternalHandleCopyAndDelete
( const CRevisionInfoContainer::CChangesIterator& first
, const CRevisionInfoContainer::CChangesIterator& last
, const CDictionaryBasedPath& revisionRootPath)
{
// any chance that this revision affects our search path?
if (!revisionRootPath.IsValid())
return false;
if (!revisionRootPath.IsSameOrParentOf (path.GetBasePath()))
return false;
// close examination of all changes
CRevisionInfoContainer::CChangesIterator bestRename = last;
for ( CRevisionInfoContainer::CChangesIterator iter = first
; iter != last
; ++iter)
{
// most entries will just be file content changes
// -> skip them efficiently
CRevisionInfoContainer::TChangeAction action = iter.GetAction();
if (action == CRevisionInfoContainer::ACTION_CHANGED)
continue;
// deletion / copy / rename / replacement
// -> skip, if our search path is not affected (only some sub-path)
CDictionaryBasedPath changedPath = iter->GetPath();
if (!changedPath.IsSameOrParentOf (path.GetBasePath()))
continue;
// now, this is serious
switch (action)
{
// rename?
case CRevisionInfoContainer::ACTION_ADDED:
case CRevisionInfoContainer::ACTION_REPLACED:
case CRevisionInfoContainer::ACTION_MOVED:
case CRevisionInfoContainer::ACTION_MOVEREPLACED:
{
if (iter.HasFromPath())
{
// continue search on copy source path
// The last copy found will also be the one closed
// to our searchPath (there may be multiple renames,
// if the base path got renamed).
assert ( ((bestRename == last)
|| (bestRename.GetPathID() < iter.GetPathID()))
&& "parent ADDs are not in strict order");
bestRename = iter;
}
else
{
// as part of a copy / rename, the parent path
// may have been added in just the same revision.
//
// example:
//
// our path: /trunk/file
// renamed to
// /trunk/project/file
//
// this can only happen if
// /trunk/project
// is added first (usually without a copy from path)
//
// Stop iteration only if we found an ADD of
// the exact search path.
if (path == changedPath)
{
// the path we are following actually started here.
addRevision = revision;
addPath = path;
revision = (revision_t)NO_REVISION;
path.Invalidate();
return true;
}
}
}
break;
case CRevisionInfoContainer::ACTION_DELETED:
{
// deletions are possible!
// but we don't need to do anything with them.
}
break;
// there should be no other
default:
{
assert (0);
}
}
}
// there was a rename / copy from some older path,rev
if (bestRename != last)
{
addRevision = revision;
addPath = path;
path = path.ReplaceParent ( bestRename.GetPath()
, bestRename.GetFromPath());
revision = bestRename.GetFromRevision();
return true;
}
// all fine, no special action required
return false;
}
void CFullHistory::BuildForwardCopies()
{
// iterate through all revisions and fill copyToRelation:
// for every copy-from info found, add an entry
const CRevisionIndex& revisions = cache->GetRevisions();
const CRevisionInfoContainer& revisionInfo = cache->GetLogInfo();
// for all revisions ...
copiesContainer.reserve (revisions.GetLastRevision());
for ( revision_t revision = revisions.GetFirstRevision()
, last = revisions.GetLastRevision()
; revision < last
; ++revision)
{
// ... in the cache ...
index_t index = revisions[revision];
if ( (index != NO_INDEX)
&& (revisionInfo.GetSumChanges (index) & CRevisionInfoContainer::HAS_COPY_FROM))
{
// ... examine all changes ...
for ( CRevisionInfoContainer::CChangesIterator
iter = revisionInfo.GetChangesBegin (index)
, end = revisionInfo.GetChangesEnd (index)
; iter != end
; ++iter)
{
// ... and if it has a copy-from info ...
if (iter->HasFromPath())
{
// ... add it to the list
SCopyInfo* copyInfo = SCopyInfo::Create (copyInfoPool);
copyInfo->fromRevision = iter->GetFromRevision();
copyInfo->fromPathIndex = iter->GetFromPathID();
copyInfo->toRevision = revision;
copyInfo->toPathIndex = iter->GetPathID();
copiesContainer.push_back (copyInfo);
}
}
}
}
// sort container by source revision and path
copyToRelation = new SCopyInfo*[copiesContainer.size()];
copyToRelationEnd = copyToRelation + copiesContainer.size();
copyFromRelation = new SCopyInfo*[copiesContainer.size()];
copyFromRelationEnd = copyFromRelation + copiesContainer.size();
// in early phases, there will be no copies
// -> front() iterator is invalid
if (!copiesContainer.empty())
{
size_t bytesToCopy = copiesContainer.size() * sizeof (SCopyInfo*[1]);
memcpy (copyToRelation, &copiesContainer.front(), bytesToCopy);
memcpy (copyFromRelation, &copiesContainer.front(), bytesToCopy);
std::sort (copyToRelation, copyToRelationEnd, &AscendingToRevision);
std::sort (copyFromRelation, copyFromRelationEnd, &AscendingFromRevision);
}
}
