/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
 
 
#include "Index.h"
 
#include "DebugSupport.h"
#include "Directory.h"
#include "Node.h"
#include "IndexImpl.h"
 
 
// #pragma mark - Index
 
 
Index::Index()
	:
	fVolume(NULL),
	fName(),
	fType(0),
	fKeyLength(0),
	fFixedKeyLength(true)
{
}
 
 
Index::~Index()
{
}
 
 
status_t
Index::Init(Volume* volume, const char* name, uint32 type, bool fixedKeyLength,
	size_t keyLength)
{
	if (!fName.SetTo(name))
		return B_NO_MEMORY;
 
	fVolume = volume;
	fType = type;
	fKeyLength = keyLength;
	fFixedKeyLength = fixedKeyLength;
 
	return B_OK;
}
 
 
bool
Index::GetIterator(IndexIterator& iterator)
{
	AbstractIndexIterator* actualIterator = InternalGetIterator();
	iterator.SetIterator(actualIterator);
 
	return actualIterator != NULL;
}
 
 
bool
Index::Find(const void* key, size_t length, IndexIterator& iterator)
{
	AbstractIndexIterator* actualIterator
		= key != NULL ? InternalFind(key, length) : NULL;
	iterator.SetIterator(actualIterator);
 
	return actualIterator != NULL;
}
 
 
void
Index::Dump()
{
	D(
		PRINT("Index: `%s', type: %" B_PRIx32 "\n", Name().Data(), Type());
		IndexIterator it;
		if (GetIterator(it)) {
			while (Node* node = it.Next()) {
				PRINT("  node: `%s', dir: %" B_PRIdINO "\n",
					node->Name().Data(), node->Parent()->ID());
			}
		}
	)
}
 
 
// #pragma mark - IndexIterator
 
 
IndexIterator::IndexIterator()
	:
	fIterator(NULL)
{
}
 
 
IndexIterator::~IndexIterator()
{
	SetIterator(NULL);
}
 
 
bool
IndexIterator::HasNext() const
{
	return fIterator != NULL && fIterator->HasNext();
}
 
 
Node*
IndexIterator::Next()
{
	return fIterator != NULL ? fIterator->Next(NULL, NULL) : NULL;
}
 
 
Node*
IndexIterator::Next(void* buffer, size_t* _keyLength)
{
	return fIterator != NULL ? fIterator->Next(buffer, _keyLength) : NULL;
}
 
 
status_t
IndexIterator::Suspend()
{
	return fIterator != NULL ? fIterator->Suspend() : B_BAD_VALUE;
}
 
 
status_t
IndexIterator::Resume()
{
	return fIterator != NULL ? fIterator->Resume() : B_BAD_VALUE;
}
 
 
void
IndexIterator::SetIterator(AbstractIndexIterator* iterator)
{
	delete fIterator;
	fIterator = iterator;
}
 
 
// #pragma mark - AbstractIndexIterator
 
 
AbstractIndexIterator::AbstractIndexIterator()
{
}
 
 
AbstractIndexIterator::~AbstractIndexIterator()
{
}
 
 
status_t
AbstractIndexIterator::Suspend()
{
	return B_OK;
}
 
 
status_t
AbstractIndexIterator::Resume()
{
	return B_OK;
}