haiku/headers/private/index_server/IndexServerAddOn.h

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


#include <Autolock.h>
#include <Entry.h>
#include <image.h>
#include <ObjectList.h>
#include <String.h>
#include <Volume.h>

#include "Referenceable.h"


class analyser_settings {
public:
						analyser_settings();

	bool				catchUpEnabled;
	//! the volume is scanned form 0 to syncPosition, from
	//! syncPosition to watchingStart the volume is not scanned
	bigtime_t			syncPosition;
	bigtime_t			watchingStart;
	bigtime_t			watchingPosition;
};


class FileAnalyser;


/*! Thread safe class to sync settings between different FileAnalyser. For
example the watcher analyser and the catch up analyser. Because the lock
overhead use it only when necessary or use a cached analyser_settings if
possible. */
class AnalyserSettings : public BReferenceable {
public:
								AnalyserSettings(const BString& name,
									const BVolume& volume);

			const BString&		Name() { return fName; }
			const BVolume&		Volume() { return fVolume; }

			bool				ReadSettings();
			bool				WriteSettings();

			analyser_settings	RawSettings();

			// settings
			void				SetCatchUpEnabled(bool enabled);
			void				SetSyncPosition(bigtime_t time);
			void				SetWatchingStart(bigtime_t time);
			void				SetWatchingPosition(bigtime_t time);

			bool				CatchUpEnabled();
			bigtime_t			SyncPosition();
			bigtime_t			WatchingStart();
			bigtime_t			WatchingPosition();
private:
			BString				fName;
			BVolume				fVolume;

			BLocker				fSettingsLock;
			analyser_settings	fAnalyserSettings;
};


class FileAnalyser {
public:
								FileAnalyser(const BString& name,
									const BVolume& volume);
	virtual						~FileAnalyser() {}

			void				SetSettings(AnalyserSettings* settings);
			AnalyserSettings*	Settings() const;
			const analyser_settings&	CachedSettings() const;
			void				UpdateSettingsCache();

			const BString&		Name() const { return fName; }
			const BVolume&		Volume() const { return fVolume; }

	virtual status_t			InitCheck() = 0;

	virtual void				AnalyseEntry(const entry_ref& ref) = 0;
	virtual void				DeleteEntry(const entry_ref& ref) { }
	virtual void				MoveEntry(const entry_ref& oldRef,
									const entry_ref& newRef) { }
	//! If the indexer send a bunch of entry this indicates that the last one
	//! has been arrived.
	virtual void				LastEntry() { }

protected:
			BVolume				fVolume;
			BReference<AnalyserSettings>	fAnalyserSettings;
			analyser_settings	fCachedSettings;
private:
			BString				fName;
};


typedef BObjectList<FileAnalyser> FileAnalyserList;


class IndexServerAddOn {
public:
	IndexServerAddOn(image_id id, const char* name)
		:
		fImageId(id),
		fName(name)
	{
	}

	virtual						~IndexServerAddOn() {}

			image_id			ImageId() { return fImageId; }
			BString				Name() { return fName; }

	virtual FileAnalyser*		CreateFileAnalyser(const BVolume& volume) = 0;

private:
		image_id				fImageId;
		BString					fName;
};


typedef IndexServerAddOn* create_index_server_addon(image_id id,
	const char* name);


#endif