FileHead.cpp #19

// FileHead.cpp: implementation of the FileHead class.
//
//////////////////////////////////////////////////////////////////////

#include <clientapi.h>
#include "filehead.h"
#include "clientloguser.h"
#include "changesorter.h"
#include "filelogcache.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

/* When a FileHead is constructed, it immediately populates itself with
 * all the necessary FileRev objects to make it a complete representation
 * of this file.  Integration records are not evaluated at this time. */
FileHead::FileHead(StrBuf path, FileLogCache* newparent)
{
	size = 0;
	name = path; //This is the path to the file.
	next = NULL;
	head = NULL;
	tail = NULL;

	next_from = NULL;
	next_into = NULL;

	flc = newparent; //The FileLogCache that created this FileHead.

	ui = new ClientLogUser;
	ui->working = this; //Tell the ClientLogUser to add revisions to this FileHead.

	if ( flc->cachefile )
	{
		if ( LoadCached( flc->cachefile ) ) return;
	}
	
	if (flc->errors->IsFatal()) return;
		
	char* args[1]; //An array that will hold the arguments to the p4 command.
	args[0] = path.Text(); //Path to the file - this will be the arg to p4 filelog.
	
	flc->client->SetArgv(1, args); //Set the argument list to be the file path.
	flc->client->RunTag( "filelog", ui ); //Run "p4 filelog <file>".

	/* At this point, the ClientLogUser takes care of creating FileRevs and
	 * arranging them.  By the time the filelog command finishes executing, it's
	 * all done. */
	
	/* Check connection and bail if dropped. */
	if (flc->client->Dropped())
	{
		flc->client->Final(flc->errors);

	}
}

/* The destructor - deletes all of its FileRevs as well as its neighboring FileHeads. */
FileHead::~FileHead()
{
	delete ui;
	if (head != NULL) {
		delete head; //deleting the head FileRev deletes them all.
	}
	if (next != NULL) {
		delete next; //pass the deletion message on to the next FileHead.
	}
}

bool FileHead::LoadCached( char* filename )
{
	FILE* file = fopen( filename, "r" );
	if ( !file ) return false;

	bool success = false;
	char* c = new char[1024];

	while ( fgets( c, 1024, file ) )
	{
		if ( !strncmp( c, name.Text(), name.Length() ) )
		{
			success = true;
			ui->OutputInfo( '0', c );
			break;
		}
	}
	if ( !success ) return false;
	while ( fgets( c, 1024, file ) )
	{
		if ( !strncmp( c, "... ... ", 8 ) ) ui->OutputInfo( '2', c+8 );
		else if ( !strncmp( c, "... ", 4 ) ) ui->OutputInfo( '1', c+4 );
		else if ( !strncmp( c, "//", 2 ) ) ui->OutputInfo( '0', c );
	}
	return true;
}

/* addRev is called from within ClientLogUser each time a new revision is given in
 * the filelog.  It adds a revision to the tail of the chain of FileRevs. */
void FileHead::addRev(StrBuf newrev, StrBuf newchange, RevType type, bool istext)
{
	/* Error checking - this will reject blatantly invalid results */
	if (
		newchange.Length() == 0 || 
		newchange.Atoi() == 0 ||
		newrev.Length() == 0 ||
		newrev.Atoi() == 0
		) return;

	size++;
	if (head != NULL) //if we already have one or more FileRevs here
	{
		tail->next = new FileRev(newrev, this, newchange, type, istext); //tack this on the end
		tail->next->prev = tail; //set its prev pointer

		/* add appropriate "edit" FileRevArrow */
		tail->AddFromArrow(tail->next, edit);

		tail = tail->next; //update the tail pointer to reflect the addition
	}
	else //this is the first revision we're adding
	{
		head = new FileRev(newrev, this, newchange, type, istext); //make it the head
		tail = head; //and make it the tail also
	}
	//add the change number to the list
	flc->changes->AddChange(newchange);
}

/* See the header file - scanInto is called when another FileHead has determined that
 * this one is its descendant.  The first argument indicates at what point this FileHead
 * received content from the donor FileHead, and the second argument indicates what specific
 * revision that integration was from. 
 * Note that scanInto operates on all the revisions from startrev-head.  Note also that
 * a FileHead's revisions start with the head and work backwards, so we'll be starting with
 * the head revision and working down until we hit startrev - when we hit startrev, we point it
 * at the "caller" FileRev and return. */
void FileHead::scanInto(StrBuf startrev, FileRev* caller, ArrowType atype)
{
	bool credit = false; //Don't start looking yet.
	FileRev* fr = tail; //fr is the FileRev we're looking at.
	FileTextArrow* text;

	/* First, precache all of the descendant branches. */
	
	while (fr != NULL) //Unless we hit the end of the line...
	{
		if (fr->rev == startrev) { //if this is the startrev
			credit = true; //begin precaching
		}
		if (credit)
		{
			if (fr->intocheck) 
			{				//Have we already checked this rev?  If so, don't do it again.
				fr = fr->prev; //move up to the next FileRev.
				continue; //Next loop.
			}
			text = fr->intotexts;
			//If no integ descendants, this will be null.
			while (text)
			{
				text->fhead = flc->Get(text->file, false, this); //get the FileHead
				text = text->next; //next textarrow
			}
		}
		fr = fr->prev; //Move on to the next FileRev.
	}

	flc->client->WaitTag();

	/* Now we scanInto all those precached FileHeads. */
	credit = false;
	fr = tail;
	while (fr != NULL) //Unless we hit the end of the line...
	{
		if (fr->rev == startrev) { //if this is the startrev
			credit = true; //begin doing scanIntos
			fr->AddFromArrow(caller, atype); //Set a from pointer to the caller FileRev.
		}
		if (credit)
		{
			if (fr->intocheck) 
			{				//Have we already checked this rev?  If so, don't do it again.
				fr = fr->prev; //move up to the next FileRev.
				continue; //Next loop.
			}
			/* If we reach this point, this rev hasn't been checked yet. */
			text = fr->intotexts;
			/* If fr doesn't have any integ children, these will be empty StrBufs. */
			while (text)
			{
				/* Here we find the FileHead representing the file from the "into"
				 * integ record.  We then scanInto it, giving the file that we're
				 * looking at right now as the "caller" arg, and the revision from
				 * the integ record as the startrev. */
				if (text->fhead->size == 0) //empty FileHead, result of an error
				{
					text = text->next;
					continue;
				}
				text->fhead->scanInto(text->rev, fr, text->type);
				text = text->next;
			}
			fr->intocheck = true; //Record the fact that this FileRev has been checked.
		}
		fr = fr->prev; //Move on to the next FileRev.
	}
}

/* scanFrom returns a FileRev* , which is then used to fill the "from" pointer
 * of its caller.  The endrev argument indicates the end of the revision range -
 * in scanFrom, we start at that rev and then work our way down to the earliest
 * revision. */
FileRev* FileHead::scanFrom(StrBuf endrev)
{
	FileTextArrow* text;
	FileRev* fr = tail; //fr is the rev we're currently looking at.
	while (fr != NULL) //for each FileRev...
	{
		if (fr->fromcheck) //If this rev has already been checked
		{
			if (fr->rev == endrev) break; //Is it the last one?
			else fr = fr->prev; //No?  Skip over it and continue.
			continue;
		}
		text = fr->fromtexts;
		while (text)
		{
			text->fhead = flc->Get(text->file, true, this); //precache the associated FileHead
			text = text->next;
		}
		if (fr->fromtexts == NULL)
		{
			fr->fromcheck = true; //no need to try to scan it later
		}
		if (fr->rev == endrev) break; //we're done precaching
		else fr = fr->prev; //otherwise, next FileRev
	}

	flc->client->WaitTag();
	/* Now the actual scans. */

	fr = tail;
	while (fr != NULL) //for each FileRev...
	{
		if (fr->fromcheck) //If this rev has already been checked
		{
			if (fr->rev == endrev) return fr; //Is it the one we want?
			else fr = fr->prev; //No?  Skip over it and continue.
			continue;
		}
		text = fr->fromtexts;
		while (text)
		{
			if (text->fhead->size == 0) //empty FileHead, result of an error
			{
				text = text->next;
				continue;
			}
			fr->AddFromArrow(text->fhead->scanFrom(text->rev), text->type);
			text = text->next;
		}
		fr->fromcheck = true; //mark this FileRev as having been scanned
		if (fr->rev == endrev) return fr; //all done!  Return it.
		else fr = fr->prev; //otherwise, next FileRev
	}
	return fr; //this line should never be executed.
}

void FileHead::scanMain() 
{
	FileTextArrow* text;
	FileRev* fr = tail; //fr is the FileRev we're looking at.

	/* In order to help make a nicely-arranged branch graph, we're going to
	 * precache all of this file's immediate relatives before tracing them
	 * to find the "extended family". */
	while (fr != NULL) //Unless we hit the end of the line...
	{
		if (!(fr->fromcheck)) 
		{
			text = fr->fromtexts;
			while (text) 
			{
				text->fhead = flc->Get(text->file, true, this); //cache the associated FileHead
				text = text->next;
			}
		}
		if (!(fr->intocheck)) 
		{
			text = fr->intotexts;
			/* If fr doesn't have any integ children, this is null. */
			while (text) //For all files in the "intofiles" list.
			{
				text->fhead = flc->Get(text->file, false, this); //cache the FileHead
				text = text->next; //next file
			}
		}
		fr = fr->prev;
	}

	flc->client->WaitTag(); //finish creating all revisions

	/* Now we finish it up by actually going through and scanning the immediate
	 * relatives. */
	fr = tail;
	while (fr != NULL)
	{
		if (!(fr->fromcheck))
		{
			fr->fromcheck = true;
			text = fr->fromtexts;
			while (text)
			{
				if (text->fhead->size == 0) //empty FileHead, result of an error
				{
					text = text->next;
					continue;
				}
				fr->AddFromArrow(text->fhead->scanFrom(text->rev), text->type);
				text = text->next;
			}
		}
		if (!(fr->intocheck))
		{
			fr->intocheck = true;
			text = fr->intotexts;
			while (text)
			{
				/* Here we find the FileHead representing the file from the "into"
				 * integ record.  We then scanInto it, giving the filerev that we're
				 * looking at right now as the "caller" arg, and the revision from
				 * the integ record as the startrev. */
				if (text->fhead->size == 0) //empty FileHead, result of an error
				{
					text = text->next;
					continue;
				}
				text->fhead->scanInto(text->rev, fr, text->type);
				text = text->next;
			}
		}
		fr = fr->prev;
	}
}