haiku.git

/*
 * 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;
}