DocManBGThread.cpp

/*
		Project:		DocMan
		Module:			DocManBGThread.cpp
		Description:	The background processor thread
		Author:			Martin Gäckler
		Address:		Hofmannsthalweg 14, A-4030 Linz
		Web:			https://www.gaeckler.at/

		Copyright:		(c) 2011-2026 Martin Gäckler

		This program is free software: you can redistribute it and/or modify
		it under the terms of the GNU General Public License as published by
		the Free Software Foundation, version 3.

		You should have received a copy of the GNU General Public License
		along with this program. If not, see <http://www.gnu.org/licenses/>.

		THIS SOFTWARE IS PROVIDED BY Martin Gäckler, Linz, Austria ``AS IS''
		AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
		TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
		PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR
		CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
		USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
		ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
		OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		SUCH DAMAGE.
*/

// --------------------------------------------------------------------- //
// ----- switches ------------------------------------------------------ //
// --------------------------------------------------------------------- //

#undef STRICT
#define STRICT 1

#define PROFILER 1

// --------------------------------------------------------------------- //
// ----- includes ------------------------------------------------------ //
// --------------------------------------------------------------------- //

#include <vcl/registry.hpp>

#include <gak/fmtNumber.h>
#include <gak/threadPool.h>
#include <gak/priorityQueue.h>
#include <gak/lockQueue.h>
#include <gak/math.h>
#include <gak/fcopy.h>
#include <gak/tmpfile.h>

#pragma hdrstop
#include <gak/memory>

#include "DocManBGThread.h"
#include "DocManDM.h"
#include "ReminderFilesFrm.h"
#include "folder.h"
#include "config.h"

// --------------------------------------------------------------------- //
// ----- imported datas ------------------------------------------------ //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- module switches ----------------------------------------------- //
// --------------------------------------------------------------------- //

#ifdef __BORLANDC__
#	pragma option -RT-
#	pragma option -b
#	pragma option -a4
#	pragma option -pc
#endif

using namespace gak;
using namespace ai;

// --------------------------------------------------------------------- //
// ----- constants ----------------------------------------------------- //
// --------------------------------------------------------------------- //

static const uint32 indexMagic = 0x8456;
static const uint16 indexVersion = 3;
static const char INDEX_START[] = "indexStart";

// --------------------------------------------------------------------- //
// ----- macros -------------------------------------------------------- //
// --------------------------------------------------------------------- //

#define getIndexFileName()	\
	F_STRING(THE_FILE::getExternalStorageBase() + "index.dat")

// --------------------------------------------------------------------- //
// ----- type definitions ---------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class definitions --------------------------------------------- //
// --------------------------------------------------------------------- //

struct IndexResult : public SharedObject
{
	StorageInfo		m_source;
	StringIndex		m_indexPositions;

	IndexResult( const StorageInfo &source, const StringIndex &stringIndex )
	: m_source( source )
	{
		m_indexPositions.moveFrom(const_cast<StringIndex &>(stringIndex));
	}

	int getPriority() const
	{
		return -m_source.storageID;
	}
};

typedef SharedPointer<StorageInfo>							IndexSourcePtr;
typedef SharedObjectPointer<IndexResult>					IndexResultPtr;
typedef PointerPriorityExtractor<IndexResult, int>			PrioExtractor;
typedef PriorityQueue<IndexResultPtr, int, PrioExtractor>	IndexPriorityQueue;
typedef LockQueue<IndexResultPtr, IndexPriorityQueue>		IndexResultQueue;

namespace gak
{
	template <>
	class FixedComparator<DocmanDirEntry>
	{
		public:
		int operator() ( const DocmanDirEntry &t1, const DocmanDirEntry &t2 ) const
		{
			int compareResult = t1.modifiedDate.compare( t2.modifiedDate );

			if( !compareResult )
			{
				compareResult = strcmpi( t1.fileName, t2.fileName );
			}
			return compareResult;
		}
	};

	template <>
	class ProcessorType<IndexSourcePtr>
	{
		IndexResultQueue	*m_resultQueue;
		gak::Set<STRING>	*m_stopWords;
		F_STRING			m_storageBase;

		public:
		typedef IndexSourcePtr	object_type;

		ProcessorType(
			IndexResultQueue	*resultQueue = nullptr,
			gak::Set<STRING>	*stopWords = nullptr,
			const F_STRING		&storageBase=F_STRING() )
		: m_storageBase( storageBase )
		{
			m_stopWords = stopWords;
			m_resultQueue = resultQueue;
		}
		void process( const IndexSourcePtr &indexSource, void *, void *  )
		{
			doEnterFunctionEx(gakLogging::llDetail,"ProcessorType<IndexSourcePtr>::process");
			assert( m_resultQueue );
			assert( m_stopWords );

			F_STRING	filePath = indexSource->storageFile;
			F_STRING	storageFile = m_storageBase + filePath;
			STRING		fileContent;
			fileContent.readFromFile( storageFile );

			StringIndex	sIndex;
			indexString( fileContent, *m_stopWords, IS_ANY, &sIndex );
			IndexResultPtr	result = IndexResultPtr(
				new IndexResult( *indexSource, sIndex )
			);
			m_resultQueue->push( result );

		}
	};
}

typedef ProcessorType<IndexSourcePtr>	IndexProcessor;
typedef ThreadPool<IndexSourcePtr>		IndexPool;

// --------------------------------------------------------------------- //
// ----- exported datas ------------------------------------------------ //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- module static data -------------------------------------------- //
// --------------------------------------------------------------------- //

static const int IDLE_TIMEOUT = 60000;
static const char STATUS_VERB[] = "Update Index";

// --------------------------------------------------------------------- //
// ----- class static data --------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- prototypes ---------------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- module functions ---------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class inlines ------------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class constructors/destructors -------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class static functions ---------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class privates ------------------------------------------------ //
// --------------------------------------------------------------------- //

// -----------------------------------------------------------------------------

bool ThreadBackground::updateIndex2()
{
	doEnterFunctionEx( gakLogging::llInfo, "ThreadBackground::updateIndex2");

	gak::Set<STRING>	stopWords;
	DocManIndex			globalIndex;
	F_STRING			storageBase = THE_FILE::getExternalStorageBase();
	F_STRING			stopWordsFile = storageBase + "stop.words.txt";
	int 				indexStart = ConfigDataModule->GetValue( INDEX_START, 0 );
	int					oldIndex = indexStart;
	bool				hasLogChanged = false;
	bool				hasStopChanged = false;

	IndexResultQueue	indexResult;
	IndexProcessor		indexProcessor( &indexResult, &stopWords, storageBase );
	IndexPool			indexPool( Thread::getNumberOfCores(), "IndexPoolThread" );

	readDocManIndex( &globalIndex );
	if( !strAccess( stopWordsFile, 0 ) )
	{
		std::ifstream	in(stopWordsFile);
		std::size_t		numWords = 0;

		while( in )
		{
			STRING word;
			in >> word;
			word.stripBlanks();

			if( !word.isEmpty() )
			{
				stopWords.addElement( word );
				numWords++;
				if( !hasStopChanged  && stopWords[stopWords.size()-1] != word )
				{
					hasStopChanged = true;
				}
			}
		}
		if( numWords != stopWords.size() )
		{
			hasStopChanged = true;
		}
	}
	if( hasStopChanged )
	{
		std::ofstream 	fp( stopWordsFile );
		fp << stopWords;
	}

	std::size_t	docReads = 0;
	indexPool.setObjectProcessor( indexProcessor );
	indexPool.start();
	StorageInfos	infos;
	int maxStorageID = DocManDataModule->selectMaxStorageID();
	int nextIndexStart = DocManDataModule->loadAllStorageInfos( indexStart, &infos )-1;
	for(
		StorageInfos::const_iterator it = infos.cbegin(),
			endIT = infos.cend();
		it != endIT;
		++it
	)
	{
#ifndef _DEBUG
		if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
		{
/*v*/		break;
		}
#endif
		const StorageInfo	&info = *it;
		STRING				mimeType = info.mimeType;
		if( mimeType.beginsWithI( "text/" ) )
		{
			++docReads;
			StatusForm->setStatus( "Indexing#1", info.storageFile );
			indexPool.process( IndexSourcePtr::makeShared( info ) );
			hasLogChanged = true;
		}
	}
	StatusForm->setStatus( STATUS_VERB, "Stoping Pool" );
	while( size_t size = indexPool.size() )
	{
		StatusForm->setStatus( STATUS_VERB, "Flush Pool " + formatNumber(size) );
		Sleep( 1000 );
	}
	indexPool.flush();
	StatusForm->setStatus( STATUS_VERB, "shutdown Pool" );
	indexPool.shutdown();
	StatusForm->restore();
	while( indexResult.size() && !StatusForm->isTerminated() )
	{
#ifndef _DEBUG
		if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
		{
/*v*/		break;
		}
#endif
		STRING			title = "Indexing#2 ("
			+ formatNumber(indexResult.size())
			+ '/'
			+ formatNumber(docReads)
			+ ')'
		;
		IndexResultPtr	result = indexResult.pop();
		StatusForm->setStatus( title, result->m_source.storageFile );
		globalIndex.moveIndexPositions( result->m_source, &result->m_indexPositions );
	}
	indexStart = gak::math::min( nextIndexStart, maxStorageID );

	if( hasLogChanged )
	{
		StatusForm->setStatus( STATUS_VERB, "Saving Index" );
		writeDocManIndex( globalIndex );

		if( !StatusForm->isTerminated() )
		{
			doEnterFunctionEx( gakLogging::llInfo, "Creating Stat");
			StatusForm->setStatus( STATUS_VERB, "Creating Stat" );
			StatistikData	data;
			globalIndex.getStatistik(&data);

			StatusForm->setStatus( STATUS_VERB, "Saving Stat" );
			STRING	logPath = Session->PrivateDir.c_str();
			STRING	logName = logPath + DIRECTORY_DELIMITER_STRING "index.log";;
			std::ofstream 	fp( logName );
			fp << "Index:\n";
			fp << data;
			fp.close();
			ShellExecute( nullptr, nullptr, logName, nullptr, nullptr, SW_SHOW );
		}
	}
	if( indexStart != oldIndex )
		ConfigDataModule->SetValue( INDEX_START, indexStart );
	if( indexStart >= m_forceIndex )
		m_forceIndex = 0;
	return hasLogChanged;
}

bool ThreadBackground::updateIndex()
{
	static unsigned s_ExceptionCount = 0;
	doEnterFunctionEx( gakLogging::llInfo, "ThreadBackground::updateIndex");

	bool hasIndexChanged = false;

	StatusForm->pushStatus( STATUS_VERB, STATUS_VERB );
	try
	{
		hasIndexChanged = updateIndex2();
		s_ExceptionCount = 0;
	}
	catch( ... )
	{
		if( ++s_ExceptionCount>3 )
			throw;
		StatusForm->incrementCounter();
	}
	StatusForm->restore();

	return hasIndexChanged;
}

// -----------------------------------------------------------------------------

void ThreadBackground::updateSyncFolders2()
{
	doEnterFunctionEx(gakLogging::llDetail,"ThreadBackground::updateSyncFolders2");

	gak::DateTime	now;
	STRING			localPath;
	bool			hasChanged;
	STRING			logPath = Session->PrivateDir.c_str();
	STRING			logName = logPath + DIRECTORY_DELIMITER_STRING "refreshDB.log";;

	SortedArray<DocmanDirEntry> localDirs;

/*
select it.ID, it.NAME
from item_tree it
where it.ITEM_TYPE = 2
or it.ITEM_TYPE = 11

select it.ID, it.parentID, it.NAME, itp.name as parentname
from item_tree it
left join item_tree itp on it.parentID = itp.ID
where it.ITEM_TYPE = 2
or it.ITEM_TYPE = 11
order by it.parentID, it.ID
*/
	/*
		collect the known directoryies
	*/
	{
		doEnterFunctionEx(gakLogging::llDetail,"collect the known directoryies");

		std::unique_ptr<TQuery> theFolderQuery( new TQuery( nullptr ) );
		theFolderQuery->DatabaseName = "docManDB";
		theFolderQuery->SQL->Add(
			"select it.ID, it.NAME "
			"from item_tree it "
			"where it.ITEM_TYPE = :TypeSyncFolder "
			"or it.ITEM_TYPE = :TypeFolderRef "
		);
		theFolderQuery->Params->Items[0]->AsInteger = TYPE_SYNC_FOLDER;
		theFolderQuery->Params->Items[1]->AsInteger = TYPE_FOLDER_REF;

		for(
			theFolderQuery->Open();
			!theFolderQuery->Eof && !StatusForm->isTerminated() && !m_forceIndex;
			theFolderQuery->Next()
		)
		{
			m_state = STRING("Checking ")+theFolderQuery->Fields->Fields[1]->AsString.c_str();
			StatusForm->pushStatus(
				"Checking",
				theFolderQuery->Fields->Fields[1]->AsString.c_str()
			);

			int				currentID = theFolderQuery->Fields->Fields[0]->AsInteger;
			PTR_FOLDER_REF	theFolder = getItem( currentID );
			if( theFolder )
			{
				m_state = localPath = theFolder->getDownloadPath();
				if( !localPath.isEmpty() )
				{
					localPath.cut( localPath.strlen()-1 );

					try
					{
						DocmanDirEntry localStat;

						localStat.findFile( localPath );

						localStat.fileName = localPath;
						localStat.dbCreatedDate = theFolder->getCreatedDate();
						localStat.dbModifiedDate = theFolder->getModifiedDate();
						localStat.itemID = currentID;
						localDirs.addElement( localStat );
					}
					catch( ... )
					{
						doLogValueEx(gakLogging::llError, localPath );
					}
				}
			}
#ifndef _DEBUG
			if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
			{
	/*v*/		break;
			}
#endif
			StatusForm->restore();
		}
		theFolderQuery->Close();
	}

	if( StatusForm->isTerminated() || m_forceIndex )
	{
/*@*/	return;
	}

	localDirs.resort();

	{
		doEnterFunctionEx(gakLogging::llDetail,"refresh directories with newer date");

		std::ofstream 	fp;

		fp.open( logName, std::ofstream::app );
		fp << "Refresh newer: " << now << '\n';
		hasChanged = false;

		/*
			refresh directories with newer date
		*/
		for(
			size_t i=localDirs.size()-1;
			i!=-1 && !StatusForm->isTerminated() && !m_forceIndex;
			i--
		)
		{
			DocmanDirEntry &curEntry = localDirs[i];
			if( curEntry.dbModifiedDate < curEntry.modifiedDate )
			{
				int				currentID = curEntry.itemID;
				PTR_FOLDER_REF	theFolder = getItem( currentID );
				if( theFolder )
				{
					m_state = localPath = curEntry.fileName;
					StatusForm->pushStatus( "Refreshing#1", localPath );
					hasChanged = theFolder->refresh( false, &fp ) || hasChanged;
					theFolder->setCreatedDate( curEntry.creationDate.calcOriginalTime() );
					theFolder->setModifiedDate( curEntry.modifiedDate.calcOriginalTime() );
					theFolder->updateDatabase();
#ifndef _DEBUG
					if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
					{
/*v*/					break;
					}
#endif
					StatusForm->restore();
				}

				curEntry.dbModifiedDate = curEntry.modifiedDate;
			}
		}
		fp << "END\n";
		fp.close();
	}
	if( hasChanged )
	{
		ShellExecute( nullptr, nullptr, logName, nullptr, nullptr, SW_SHOW );
	}
	if( StatusForm->isTerminated() || m_forceIndex )
	{
/*@*/	return;
	}

	/*
		refresh directories changed date
	*/
	{
		doEnterFunctionEx(gakLogging::llDetail,"refresh directories changed date");

		std::ofstream 	fp;
		fp.open( logName, std::ofstream::app );
		fp << "Refresh changed: " << now << '\n';
		hasChanged = false;
		for(
			size_t i=localDirs.size()-1;
			i!=-1 && !StatusForm->isTerminated() && !m_forceIndex;
			i--
		)
		{
			DocmanDirEntry &curEntry = localDirs[i];
			if( curEntry.dbModifiedDate != curEntry.modifiedDate )
			{
				int				currentID = curEntry.itemID;
				PTR_FOLDER_REF	theFolder = getItem( currentID );
				if( theFolder )
				{
					m_state = localPath = curEntry.fileName;
					StatusForm->pushStatus( "Refreshing#2", localPath );
					hasChanged = theFolder->refresh( false, &fp ) || hasChanged;
					theFolder->setCreatedDate( curEntry.creationDate.calcOriginalTime() );
					theFolder->setModifiedDate( curEntry.modifiedDate.calcOriginalTime() );
					theFolder->updateDatabase();
#ifndef _DEBUG
					if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
					{
/*v*/					break;
					}
#endif
					StatusForm->restore();
				}
				curEntry.dbModifiedDate = curEntry.modifiedDate;
			}
		}
		fp << "END\n";
		fp.close();
	}
	if( hasChanged )
	{
		ShellExecute( nullptr, nullptr, logName, nullptr, nullptr, SW_SHOW );
	}
	if( StatusForm->isTerminated() || m_forceIndex )
	{
/*@*/	return;
	}

	/*
		refresh ALL directories
	*/
	{
		doEnterFunctionEx(gakLogging::llDetail,"refresh ALL directories");
		std::ofstream 	fp;
		fp.open( logName, std::ofstream::app );
		fp << "Refresh all: " << now << '\n';
		hasChanged = false;
		for(
			size_t i=localDirs.size()-1;
			i!=-1 && !StatusForm->isTerminated() && !m_forceIndex;
			i--
		)
		{
			const DocmanDirEntry	&curEntry = localDirs[i];
			int						currentID = curEntry.itemID;
			PTR_FOLDER_REF			theFolder = getItem( currentID );
			if( theFolder )
			{
				m_state = localPath = curEntry.fileName;
				StatusForm->pushStatus( "Refreshing#3", localPath );
				hasChanged = theFolder->refresh( false, &fp ) || hasChanged;
				theFolder->setCreatedDate( curEntry.creationDate.calcOriginalTime() );
				theFolder->setModifiedDate( curEntry.modifiedDate.calcOriginalTime() );
				theFolder->updateDatabase();
#ifndef _DEBUG
				if( StatusForm->waitForUserSleep( IDLE_TIMEOUT ) )
				{
/*v*/				break;
				}
#endif
				StatusForm->restore();
			}
		}
		fp << "END\n";
		fp.close();
	}
	if( hasChanged )
	{
		ShellExecute( nullptr, nullptr, logName, nullptr, nullptr, SW_SHOW );
	}
}

void ThreadBackground::updateSyncFolders()
{
	static unsigned s_ExceptionCount = 0;

	doEnterFunctionEx(gakLogging::llDetail,"ThreadBackground::updateSyncFolders");

	try
	{
		updateSyncFolders2();
		s_ExceptionCount = 0;
	}
	catch( ... )
	{
		if( ++s_ExceptionCount>3 )
			throw;
		StatusForm->incrementCounter();
	}
}

// -----------------------------------------------------------------------------

void ThreadBackground::reminderCheck()
{
	static unsigned s_ExceptionCount = 0;

	doEnterFunctionEx( gakLogging::llInfo, "ThreadBackground::reminderCheck" );
	STRING oldState = m_state;

	m_state = "openChecked";
	try
	{

		if( ReminderFilesForm->openChecked() )
		{
			Application->MessageBox("There are files to keep in mind.", "Doc Man", MB_OK);
		}
		s_ExceptionCount = 0;
	}
	catch( ... )
	{
		if( ++s_ExceptionCount > 3 )
			throw;
		StatusForm->incrementCounter();
	}
	m_state = oldState;
}

// --------------------------------------------------------------------- //
// ----- class protected ----------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- class virtuals ------------------------------------------------ //
// --------------------------------------------------------------------- //

const char *ThreadBackground::getTitle() const
{
	return "Background Process";
}

void ThreadBackground::perform()
{
	doEnterFunctionEx(gakLogging::llDetail,"ThreadBackground::perform");

	TDateTime					lastCheck = 0;
	std::unique_ptr<TRegistry>	registry( new TRegistry );

	if( registry->OpenKey( registryKey, true ) )
	{
		if( registry->ValueExists( "bgLastCheck" ) )
		{
			lastCheck = registry->ReadDate( "bgLastCheck" );
		}
	}

	try
	{
		while( !StatusForm->isTerminated() )
		{
			reminderCheck();

			m_state = "updateIndex";
			bool hasIndexChanged = updateIndex();
			if( StatusForm->isTerminated() )
			{
/*v*/			break;
			}

			reminderCheck();

			if( !hasIndexChanged )
			{
				m_state = "updateSyncFolders";
				updateSyncFolders();
				if( StatusForm->isTerminated() )
				{
/*v*/				break;
				}

				reminderCheck();

				m_state = "checkDB";
				if( (int(TDateTime::CurrentDate()) - int(lastCheck)) >= 7 )
				{
					DocManDataModule->checkDB( true, &m_forceIndex );
					if( !m_forceIndex )
					{
						lastCheck = TDateTime::CurrentDate();
#ifndef _DEBUG
						registry->WriteDate( "bgLastCheck", lastCheck );
#endif
					}
				}
			}

			if( StatusForm->isTerminated() )
			{
/*v*/			break;
			}
			clearItemCache();

			reminderCheck();

			if( !hasIndexChanged && !m_forceIndex )
			{
				m_state = "Sleep";
				StatusForm->pushStatus( "Sleeping", "" );
				gak::DateTime	now;
				STRING dateTime = now.getLocalTime();
				do
				{
					gak::Time	inpTime( GetLastInputTime() );
					STRING		inputTime = inpTime.toString();

					StatusForm->pushStatus( "Sleeping since ", dateTime + " Idle for: " + inputTime );
					Sleep( 60000  );
					reminderCheck();
					StatusForm->restore();
				}
				while( GetLastInputTime() > 600000 && !StatusForm->isTerminated() && !m_forceIndex );


				StatusForm->restore();
			}
		}	// while( !StatusForm->isTerminated() )
	}
	catch( Exception &e )
	{
		m_errorText = m_state + '\n' + e.Message.c_str();
	}
	catch( std::exception &e )
	{
		m_errorText = m_state + '\n' + e.what();
	}
	catch( ... )
	{
		m_errorText = m_state + "\nAn unkown error had occured";
	}
}

// --------------------------------------------------------------------- //
// ----- class publics ------------------------------------------------- //
// --------------------------------------------------------------------- //

// --------------------------------------------------------------------- //
// ----- entry points -------------------------------------------------- //
// --------------------------------------------------------------------- //

void readDocManIndex( DocManIndex *index )
{
	doEnterFunctionEx(gakLogging::llDetail,"readDocManIndex");
	F_STRING indexFile = getIndexFileName();
	try
	{
		if( !strAccess( indexFile, 0 ) )
		{
			readFromBinaryFile( indexFile, index, indexMagic, indexVersion, false );
		}
	}
	catch( std::exception &e )
	{
		strRemove( indexFile );
		throw Exception( e.what() );
	}
}

void writeDocManIndex( const DocManIndex &index )
{
	doEnterFunctionEx(gakLogging::llInfo,"writeDocManIndex");
	F_STRING indexFile = getIndexFileName();

	TempFileName	tmpFile(true);
	const STRING	&tmp = tmpFile.get();
	writeToBinaryFile( tmp, index, indexMagic, indexVersion, owmOverwrite );

	STRING newFile = indexFile + ".tmp";
	STRING oldFile = indexFile + ".old";

	fcopy(tmp, newFile);
	strRemove(oldFile);
	strRename(indexFile, oldFile);
	strRename(newFile, indexFile);
}

void deleteDocManIndex()
{
	doEnterFunctionEx(gakLogging::llDetail,"deleteDocManIndex");
	F_STRING indexFile = getIndexFileName();
	strRemove(indexFile);
	ConfigDataModule->SetValue( INDEX_START, 0 );
}

#ifdef __BORLANDC__
#	pragma option -RT.
#	pragma option -b.
#	pragma option -a.
#	pragma option -p.
#endif