haiku.git

/*
 * Copyright 2007, Ingo Weinhold, ingo_weinhold@gmx.de.
 * All rights reserved. Distributed under the terms of the MIT license.
 */

#include <TypeConstants.h>

#include "DebugSupport.h"
#include "Entry.h"
#include "IndexImpl.h"
#include "NameIndex.h"
#include "ramfs.h"
#include "Volume.h"

// NameIndexPrimaryKey
class NameIndexPrimaryKey {
public:
	NameIndexPrimaryKey(const Entry *entry,
						const char *name = NULL)
		: entry(entry), name(name ? name : entry->GetName()) {}
	NameIndexPrimaryKey(const char *name)
		: entry(NULL), name(name) {}

	const Entry	*entry;
	const char	*name;
};

// NameIndexGetPrimaryKey
class NameIndexGetPrimaryKey {
public:
	inline NameIndexPrimaryKey operator()(const Entry *a)
	{
		return NameIndexPrimaryKey(a);
	}

	inline NameIndexPrimaryKey operator()(const Entry *a) const
	{
		return NameIndexPrimaryKey(a);
	}
};


// NameIndexPrimaryKeyCompare
class NameIndexPrimaryKeyCompare
{
public:
	inline int operator()(const NameIndexPrimaryKey &a,
						  const NameIndexPrimaryKey &b) const
	{
		if (a.entry != NULL && a.entry == b.entry)
			return 0;
		return strcmp(a.name, b.name);
	}
};


// EntryTree

typedef TwoKeyAVLTree<Entry*, NameIndexPrimaryKey, NameIndexPrimaryKeyCompare,
					  NameIndexGetPrimaryKey>
		_EntryTree;

class NameIndex::EntryTree : public _EntryTree {};


// NameIndexEntryIterator
class NameIndexEntryIterator : public AbstractIndexEntryIterator,
	public EntryListener {
public:
	NameIndexEntryIterator();
	virtual ~NameIndexEntryIterator();

	virtual Entry *GetCurrent();
	virtual Entry *GetCurrent(uint8 *buffer, size_t *keyLength);
	virtual Entry *GetPrevious();
	virtual Entry *GetNext();

	virtual status_t Suspend();
	virtual status_t Resume();

	bool SetTo(NameIndex *index, const char *name, bool ignoreValue = false);

	virtual void EntryRemoved(Entry *entry);

private:
	friend class NameIndex;

	typedef AbstractIndexEntryIterator BaseClass;

private:
	NameIndex						*fIndex;
	NameIndex::EntryTree::Iterator	fIterator;
	bool							fSuspended;
	bool							fIsNext;
};


// NameIndex

// constructor
NameIndex::NameIndex(Volume *volume)
	: Index(volume, "name", B_STRING_TYPE, false),
	  fEntries(new(nothrow) EntryTree)
{
	if (fInitStatus == B_OK && !fEntries)
		fInitStatus = B_NO_MEMORY;
	if (fInitStatus == B_OK) {
		fInitStatus = fVolume->AddEntryListener(this,
			NULL, ENTRY_LISTEN_ANY_ENTRY | ENTRY_LISTEN_ALL);
	}
}

// destructor
NameIndex::~NameIndex()
{
	if (fVolume)
		fVolume->RemoveEntryListener(this, NULL);
	if (fEntries)
		delete fEntries;
	// Actually we would need to maintain a list of iterators and unset the
	// still existing iterators here. But since the name index is deleted
	// when the volume is unmounted, there shouldn't be any iterators left
	// anymore.
}

// CountEntries
int32
NameIndex::CountEntries() const
{
	return fEntries->CountItems();
}

// Changed
status_t
NameIndex::Changed(Entry *entry, const char *oldName)
{
	status_t error = B_BAD_VALUE;
	if (entry && oldName) {
		EntryTree::Iterator it;
		Entry **foundEntry
			= fEntries->Find(NameIndexPrimaryKey(entry, oldName), entry, &it);
		if (foundEntry && *foundEntry == entry) {
			it.Remove();
			error = fEntries->Insert(entry);

			// udpate live queries
			_UpdateLiveQueries(entry, oldName, entry->GetName());
		}
	}
	return error;
}

// EntryAdded
void
NameIndex::EntryAdded(Entry *entry)
{
	if (entry) {
		fEntries->Insert(entry);

		// udpate live queries
		_UpdateLiveQueries(entry, NULL, entry->GetName());
	}
}

// EntryRemoved
void
NameIndex::EntryRemoved(Entry *entry)
{
	if (entry) {
		fEntries->Remove(entry, entry);

		// udpate live queries
		_UpdateLiveQueries(entry, entry->GetName(), NULL);
	}
}

// InternalGetIterator
AbstractIndexEntryIterator *
NameIndex::InternalGetIterator()
{
	NameIndexEntryIterator *iterator = new(nothrow) NameIndexEntryIterator;
	if (iterator) {
		if (!iterator->SetTo(this, NULL, true)) {
			delete iterator;
			iterator = NULL;
		}
	}
	return iterator;
}

// InternalFind
AbstractIndexEntryIterator *
NameIndex::InternalFind(const uint8 *key, size_t length)
{
	if (!key || length == 0)
		return NULL;

	// if the key is not null-terminated, copy it
	uint8 clonedKey[kMaxIndexKeyLength];
	if (key[length - 1] != '\0') {
		if (length >= kMaxIndexKeyLength)
			length = kMaxIndexKeyLength - 1;

		memcpy(clonedKey, key, length);
		clonedKey[length] = '\0';
		length++;
		key = clonedKey;
	}

	NameIndexEntryIterator *iterator = new(nothrow) NameIndexEntryIterator;
	if (iterator) {
		if (!iterator->SetTo(this, (const char *)key)) {
			delete iterator;
			iterator = NULL;
		}
	}
	return iterator;
}

// _UpdateLiveQueries
void
NameIndex::_UpdateLiveQueries(Entry* entry, const char* oldName,
	const char* newName)
{
	fVolume->UpdateLiveQueries(entry, entry->GetNode(), GetName(),
		GetType(), (const uint8*)oldName, (oldName ? strlen(oldName) : 0),
		(const uint8*)newName, (newName ? strlen(newName) : 0));
}


// NameIndexEntryIterator

// constructor
NameIndexEntryIterator::NameIndexEntryIterator()
	: AbstractIndexEntryIterator(),
	  fIndex(NULL),
	  fIterator(),
	  fSuspended(false),
	  fIsNext(false)
{
}

// destructor
NameIndexEntryIterator::~NameIndexEntryIterator()
{
	SetTo(NULL, NULL);
}

// GetCurrent
Entry *
NameIndexEntryIterator::GetCurrent()
{
	return (fIndex && fIterator.GetCurrent() ? *fIterator.GetCurrent() : NULL);
}

// GetCurrent
Entry *
NameIndexEntryIterator::GetCurrent(uint8 *buffer, size_t *keyLength)
{
	Entry *entry = GetCurrent();
	if (entry) {
		strncpy((char*)buffer, entry->GetName(), kMaxIndexKeyLength);
		*keyLength = strlen(entry->GetName());
	}
	return entry;
}

// GetPrevious
Entry *
NameIndexEntryIterator::GetPrevious()
{
	if (fSuspended)
		return NULL;
	if (!(fIterator.GetCurrent() && fIsNext))
		fIterator.GetPrevious();
	fIsNext = false;
	return (fIndex && fIterator.GetCurrent() ? *fIterator.GetCurrent() : NULL);
}

// GetNext
Entry *
NameIndexEntryIterator::GetNext()
{
	if (fSuspended)
		return NULL;
	if (!(fIterator.GetCurrent() && fIsNext))
		fIterator.GetNext();
	fIsNext = false;
	return (fIndex && fIterator.GetCurrent() ? *fIterator.GetCurrent() : NULL);
}

// Suspend
status_t
NameIndexEntryIterator::Suspend()
{
	status_t error = (!fSuspended ? B_OK : B_BAD_VALUE);
	if (error == B_OK) {
		if (fIterator.GetCurrent()) {
			error = fIndex->GetVolume()->AddEntryListener(this,
				*fIterator.GetCurrent(), ENTRY_LISTEN_REMOVED);
		}
		if (error == B_OK)
			fSuspended = true;
	}
	return error;
}

// Resume
status_t
NameIndexEntryIterator::Resume()
{
	status_t error = (fSuspended ? B_OK : B_BAD_VALUE);
	if (error == B_OK) {
		if (fIterator.GetCurrent()) {
			error = fIndex->GetVolume()->RemoveEntryListener(this,
				*fIterator.GetCurrent());
		}
		if (error == B_OK)
			fSuspended = false;
	}
	return error;
}

// SetTo
bool
NameIndexEntryIterator::SetTo(NameIndex *index, const char *name,
							  bool ignoreValue)
{
	Resume();
	fIndex = index;
	fSuspended = false;
	fIsNext = false;
	if (fIndex) {
		if (ignoreValue) {
			fIndex->fEntries->GetIterator(&fIterator);
			return fIterator.GetCurrent();
		}
		return fIndex->fEntries->FindFirst(name, &fIterator);
	}
	return false;
}

// EntryRemoved
void
NameIndexEntryIterator::EntryRemoved(Entry */*entry*/)
{
	Resume();
	fIsNext = GetNext();
	Suspend();
}