haiku.git

/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "SizeIndex.h"

#include <new>

#include <TypeConstants.h>

#include <util/SinglyLinkedList.h>

#include "DebugSupport.h"
#include "IndexImpl.h"
#include "Node.h"
#include "TwoKeyAVLTree.h"
#include "Volume.h"


// #pragma mark - SizeIndexPrimaryKey


class SizeIndexPrimaryKey {
public:
	SizeIndexPrimaryKey(Node* node, off_t size)
		:
		node(node),
		size(size)
	{
	}

	SizeIndexPrimaryKey(Node* node)
		:
		node(node),
		size(node->FileSize())
	{
	}

	SizeIndexPrimaryKey(off_t size)
		:
		node(NULL),
		size(size)
	{
	}

	Node*	node;
	off_t	size;
};


// #pragma mark - SizeIndexGetPrimaryKey


class SizeIndexGetPrimaryKey {
public:
	inline SizeIndexPrimaryKey operator()(Node* a)
	{
		return SizeIndexPrimaryKey(a);
	}

	inline SizeIndexPrimaryKey operator()(Node* a) const
	{
		return SizeIndexPrimaryKey(a);
	}
};


// #pragma mark - SizeIndexPrimaryKeyCompare


class SizeIndexPrimaryKeyCompare {
public:
	inline int operator()(const SizeIndexPrimaryKey &a,
		const SizeIndexPrimaryKey &b) const
	{
		if (a.node != NULL && a.node == b.node)
			return 0;
		if (a.size < b.size)
			return -1;
		if (a.size > b.size)
			return 1;
		return 0;
	}
};


// #pragma mark - NodeTree


typedef TwoKeyAVLTree<Node*, SizeIndexPrimaryKey, SizeIndexPrimaryKeyCompare,
	SizeIndexGetPrimaryKey> _NodeTree;
class SizeIndex::NodeTree : public _NodeTree {};


// #pragma mark - IteratorList


class SizeIndex::IteratorList : public SinglyLinkedList<Iterator> {};


// #pragma mark - Iterator


struct SizeIndex::IteratorPolicy {
	typedef SizeIndex										Index;
	typedef off_t											Value;
	typedef SizeIndex::NodeTree								NodeTree;
	typedef GenericIndexIteratorTreePolicy<IteratorPolicy>	TreePolicy;

	static NodeTree* GetNodeTree(Index* index)
	{
		return index->fNodes;
	}

	static void GetNodeValue(Node* node, void* buffer, size_t* _keyLength)
	{
		*(off_t*)buffer = node->FileSize();
		*_keyLength = sizeof(off_t);
	}
};


class SizeIndex::Iterator : public GenericIndexIterator<IteratorPolicy>,
	public SinglyLinkedListLinkImpl<Iterator> {
public:
	virtual	void				NodeChanged(Node* node, uint32 statFields,
									const OldNodeAttributes& oldAttributes);
};


// #pragma mark - SizeIndex


SizeIndex::SizeIndex()
	:
	Index(),
	fNodes(NULL),
	fIteratorsToUpdate(NULL)
{
}


SizeIndex::~SizeIndex()
{
	if (IsListening())
		fVolume->RemoveNodeListener(this);

	ASSERT(fIteratorsToUpdate->IsEmpty());

	delete fIteratorsToUpdate;
	delete fNodes;
}


status_t
SizeIndex::Init(Volume* volume)
{
	status_t error = Index::Init(volume, "size", B_INT64_TYPE, true,
		sizeof(off_t));
	if (error != B_OK)
		return error;

	fVolume->AddNodeListener(this, NULL);

	fNodes = new(std::nothrow) NodeTree;
	fIteratorsToUpdate = new(std::nothrow) IteratorList;
	if (fNodes == NULL || fIteratorsToUpdate == NULL)
		return B_NO_MEMORY;

	return B_OK;
}


int32
SizeIndex::CountEntries() const
{
	return fNodes->CountItems();
}


void
SizeIndex::NodeAdded(Node* node)
{
	fNodes->Insert(node);
}


void
SizeIndex::NodeRemoved(Node* node)
{
	fNodes->Remove(node, node);
}


void
SizeIndex::NodeChanged(Node* node, uint32 statFields,
	const OldNodeAttributes& oldAttributes)
{
	IteratorList iterators;
	iterators.TakeFrom(fIteratorsToUpdate);

	off_t oldSize = oldAttributes.FileSize();
	off_t newSize = node->FileSize();
	if (newSize == oldSize)
		return;

	NodeTree::Iterator nodeIterator;
	Node** foundNode = fNodes->Find(SizeIndexPrimaryKey(node, oldSize), node,
		&nodeIterator);

	if (foundNode == NULL || *foundNode != node)
		return;

	// move the iterators that point to the node to the previous node
	for (IteratorList::ConstIterator it = iterators.GetIterator();
			Iterator* iterator = it.Next();) {
		iterator->NodeChangeBegin(node);
	}

	// remove and re-insert the node
	nodeIterator.Remove();
	if (fNodes->Insert(node) != B_OK) {
		fIteratorsToUpdate->MakeEmpty();
		return;
	}

	// Move the iterators to the next node again. If the node hasn't changed
	// its place, they will point to it again, otherwise to the node originally
	// succeeding it.
	for (IteratorList::ConstIterator it = iterators.GetIterator();
			Iterator* iterator = it.Next();) {
		iterator->NodeChangeEnd(node);
	}

	// update live queries
	fVolume->UpdateLiveQueries(node, Name(), Type(),
		(const uint8*)&oldSize, sizeof(oldSize), (const uint8*)&newSize,
		sizeof(newSize));
}


AbstractIndexIterator*
SizeIndex::InternalGetIterator()
{
	Iterator* iterator = new(std::nothrow) Iterator;
	if (iterator != NULL) {
		if (!iterator->SetTo(this, 0, true)) {
			delete iterator;
			iterator = NULL;
		}
	}
	return iterator;
}


AbstractIndexIterator*
SizeIndex::InternalFind(const void* key, size_t length)
{
	if (length != sizeof(off_t))
		return NULL;
	Iterator* iterator = new(std::nothrow) Iterator;
	if (iterator != NULL) {
		if (!iterator->SetTo(this, *(const off_t*)key)) {
			delete iterator;
			iterator = NULL;
		}
	}
	return iterator;
}


void
SizeIndex::_AddIteratorToUpdate(Iterator* iterator)
{
	fIteratorsToUpdate->Add(iterator);
}


// #pragma mark - Iterator


void
SizeIndex::Iterator::NodeChanged(Node* node, uint32 statFields,
	const OldNodeAttributes& oldAttributes)
{
	fIndex->_AddIteratorToUpdate(this);
}