diffmulti.h
#1

/*
* Copyright 2002 Perforce Software. All rights reserved.
*
* This file is part of Perforce - the FAST SCM System.
*/
/*
* MultiMerge - merge a bunch of files and return a merged list
*
* MultiMerge is the basis for an 'annotate' command, which shows
* all version of a file combined into a single stream, with each
* line marked with the applicable revisions.
*
* MutliMerge does the work of merging a bunch of separate files
* (each distinguished internally by revId) and producing the resulting
* stream. It does so taking one file at a time, diffing it against the
* previous, and using the diff to merge the new file's lines into the
* existing list of lines. The result is a list (chain, actually) of all
* the lines of all the files, with each line marked with the first and
* last revision the line was seen in.
*
* If a line disappears in one rev and reappears in a later, it will seem
* to be two separate lines, as we can only represent a single range of
* revs and doing the n x n diffs would be too expensie anyhow.
*
* Classes defined:
* MultiMerge - the multiple file merger
*
* Public methods:
* MultiMerge::Add() - add the next file to the merged stream
* MultiMerge::Dump() - (debugging) write the merged stream to stdout
* MultiMerge::Read() - extra the merged result, a line at a time
*
* Note:
* MultiMerge::Add() takes possession of the FileSys handed it,
* and deletes it when done.
*/
struct MergeLine;
struct MergeSequence;
class MultiMerge
{
public:
MultiMerge( StrPtr *diffFlags = 0 );
~MultiMerge();
void Add( FileSys *f, int revId, int chgId, Error *e );
void Dump();
MergeLine *Read( int &lower, int &upper, StrPtr &string, int chg );
MergeLine *FirstLine() { return chain; } // for FileMultiMerge
int index; // for MultiMultiMerge
private:
MergeSequence *fx;
MergeLine *chain;
MergeLine *reader;
DiffFlags flags;
} ;
/*
* MergeLine - a list of lines representing the merge of many files
*
* A MergeLine chain represents the merge of many files. It starts as
* linked list of lines of one file. (The lines are actually the entries
* of a diff sequence, usually the same thing.) Each time a file is merged
* in, the diff between the previous file and the new file dictates the
* insertion of new lines into the chain.
*
* Each line is marked with a lowerRev and upperRev. The lowerRev is the
* rev when the line is added. The upperRev is the highest rev the line
* was seen in. When a new file is diffed against the previous, there are
* three possible states for existing lines:
*
* upperRev < rev of previous file:
* these are ignored when counting lines, as they didn't
* participate in the diff.
*
* upperRev == rev of previous file, and line is in new file as well:
* upperRev gets reset to rev of new file
*
* upperRev == rev of previous file, but line not in new file:
* upperRev is left as rev of previous file, thus being
* ignored on subsequent passes.
*/
struct MergeLine
{
MergeLine *next;
int lowerRev;
int upperRev;
int lowerChg;
int upperChg;
MergeLine *from; // integ source
StrBuf buf;
MultiMerge *merge;
static MergeLine **AddLines(
MergeLine **p,
MergeSequence *f,
MultiMerge *m,
LineNo s,
LineNo e );
static MergeLine **MarkLines(
MergeLine **p,
LineNo count,
int prevRev,
int nextRev,
int prevChg,
int nextChg );
} ;