haiku/src/add-ons/index_server/IndexServerAddOn.cpp

/*
 * Copyright 2010, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Clemens Zeidler <haiku@clemens-zeidler.de>
 */

#include "IndexServerAddOn.h"

#include <Debug.h>
#include <Directory.h>
#include <File.h>
#include <Path.h>

#include "IndexServerPrivate.h"


analyser_settings::analyser_settings()
	:
	catchUpEnabled(true),

	syncPosition(0),
	watchingStart(0),
	watchingPosition(0)
{
	
}


const char* kAnalyserStatusFile = "AnalyserStatus";

const char* kCatchUpEnabledAttr = "CatchUpEnabled";
const char* kSyncPositionAttr = "SyncPosition";
const char* kWatchingStartAttr = "WatchingStart";
const char* kWatchingPositionAttr = "WatchingPosition";


AnalyserSettings::AnalyserSettings(const BString& name, const BVolume& volume)
	:
	fName(name),
	fVolume(volume)
{
	ReadSettings();
}


bool
AnalyserSettings::ReadSettings()
{
	BAutolock _(fSettingsLock);

	BDirectory rootDir;
	fVolume.GetRootDirectory(&rootDir);
	BPath path(&rootDir);
	path.Append(kIndexServerDirectory);
	path.Append(fName);
	path.Append(kAnalyserStatusFile);

	BFile file(path.Path(), B_READ_ONLY);
	if (file.InitCheck() != B_OK)
		return false;

	uint32 value;
	file.ReadAttr(kCatchUpEnabledAttr, B_UINT32_TYPE, 0, &value,
		sizeof(uint32));
	fAnalyserSettings.catchUpEnabled = value != 0 ? true : false;
	file.ReadAttr(kSyncPositionAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.syncPosition, sizeof(int64));
	file.ReadAttr(kWatchingStartAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.watchingStart, sizeof(int64));
	file.ReadAttr(kWatchingPositionAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.watchingPosition, sizeof(int64));

	return true;
}


bool
AnalyserSettings::WriteSettings()
{
	BAutolock _(fSettingsLock);

	BDirectory rootDir;
	fVolume.GetRootDirectory(&rootDir);
	BPath path(&rootDir);
	path.Append(kIndexServerDirectory);
	path.Append(fName);
	if (create_directory(path.Path(), 777) != B_OK)
		return false;
	path.Append(kAnalyserStatusFile);
	
	BFile file(path.Path(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
	if (file.InitCheck() != B_OK)
		return false;

	uint32 value = fAnalyserSettings.catchUpEnabled ? 1 : 0;
	file.WriteAttr(kCatchUpEnabledAttr, B_UINT32_TYPE, 0, &value,
		sizeof(uint32));
	file.WriteAttr(kSyncPositionAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.syncPosition, sizeof(int64));
	file.WriteAttr(kWatchingStartAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.watchingStart, sizeof(int64));
	file.WriteAttr(kWatchingPositionAttr, B_INT64_TYPE, 0,
		&fAnalyserSettings.watchingPosition, sizeof(int64));

	return true;
}


analyser_settings
AnalyserSettings::RawSettings()
{
	BAutolock _(fSettingsLock);

	return fAnalyserSettings;
}


void
AnalyserSettings::SetCatchUpEnabled(bool enabled)
{
	BAutolock _(fSettingsLock);

	fAnalyserSettings.catchUpEnabled = enabled;
}


void
AnalyserSettings::SetSyncPosition(bigtime_t time)
{
	BAutolock _(fSettingsLock);

	fAnalyserSettings.syncPosition = time;
}


void
AnalyserSettings::SetWatchingStart(bigtime_t time)
{
	BAutolock _(fSettingsLock);

	fAnalyserSettings.watchingStart = time;
}


void
AnalyserSettings::SetWatchingPosition(bigtime_t time)
{
	BAutolock _(fSettingsLock);

	fAnalyserSettings.watchingPosition = time;
}


bool
AnalyserSettings::CatchUpEnabled()
{
	BAutolock _(fSettingsLock);

	return fAnalyserSettings.catchUpEnabled;
}


bigtime_t
AnalyserSettings::SyncPosition()
{
	BAutolock _(fSettingsLock);

	return fAnalyserSettings.syncPosition;
}


bigtime_t
AnalyserSettings::WatchingStart()
{
	BAutolock _(fSettingsLock);

	return fAnalyserSettings.watchingStart;
}


bigtime_t
AnalyserSettings::WatchingPosition()
{
	BAutolock _(fSettingsLock);

	return fAnalyserSettings.watchingPosition;
}


FileAnalyser::FileAnalyser(const BString& name, const BVolume& volume)
	:
	fVolume(volume),
	fName(name)
{

}


void
FileAnalyser::SetSettings(AnalyserSettings* settings)
{
	ASSERT(fName == settings->Name() && fVolume == settings->Volume());

	fAnalyserSettings = settings;
	ASSERT(fAnalyserSettings.Get());
	UpdateSettingsCache();
}


AnalyserSettings*
FileAnalyser::Settings() const
{
	return fAnalyserSettings;
}


const analyser_settings&
FileAnalyser::CachedSettings() const
{
	return fCachedSettings;
}


void
FileAnalyser::UpdateSettingsCache()
{
	fCachedSettings = fAnalyserSettings->RawSettings();
}