haiku.git

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


#include "GlobalTypeLookup.h"

#include <new>

#include <String.h>

#include <AutoLocker.h>

#include "Type.h"
#include "TypeLookupConstraints.h"


struct GlobalTypeCache::TypeEntry {
	Type*		type;
	TypeEntry*	fNextByName;
	TypeEntry*	fNextByID;

	TypeEntry(Type* type)
		:
		type(type)
	{
		type->AcquireReference();
	}

	~TypeEntry()
	{
		type->ReleaseReference();
	}
};


struct GlobalTypeCache::TypeEntryHashDefinitionByName {
	typedef const BString	KeyType;
	typedef	TypeEntry		ValueType;

	size_t HashKey(const BString& key) const
	{
		return key.HashValue();
	}

	size_t Hash(const TypeEntry* value) const
	{
		return HashKey(value->type->Name());
	}

	bool Compare(const BString& key, const TypeEntry* value) const
	{
		return key == value->type->Name();
	}

	TypeEntry*& GetLink(TypeEntry* value) const
	{
		return value->fNextByName;
	}
};


struct GlobalTypeCache::TypeEntryHashDefinitionByID {
	typedef const BString	KeyType;
	typedef	TypeEntry		ValueType;

	size_t HashKey(const BString& key) const
	{
		return key.HashValue();
	}

	size_t Hash(const TypeEntry* value) const
	{
		return HashKey(value->type->ID());
	}

	bool Compare(const BString& key, const TypeEntry* value) const
	{
		return key == value->type->ID();
	}

	TypeEntry*& GetLink(TypeEntry* value) const
	{
		return value->fNextByID;
	}
};


// #pragma mark - GlobalTypeCache


GlobalTypeCache::GlobalTypeCache()
	:
	fLock("global type cache"),
	fTypesByName(NULL),
	fTypesByID(NULL)
{
}


GlobalTypeCache::~GlobalTypeCache()
{
	if (fTypesByName != NULL)
		fTypesByName->Clear();

	// release all cached type references
	if (fTypesByID != NULL) {
		TypeEntry* entry = fTypesByID->Clear(true);
		while (entry != NULL) {
			TypeEntry* nextEntry = entry->fNextByID;
			delete entry;
			entry = nextEntry;
		}
	}

	delete fTypesByName;
	delete fTypesByID;
}


status_t
GlobalTypeCache::Init()
{
	// check lock
	status_t error = fLock.InitCheck();
	if (error != B_OK)
		return error;

	// create name table
	fTypesByName = new(std::nothrow) NameTable;
	if (fTypesByName == NULL)
		return B_NO_MEMORY;

	error = fTypesByName->Init();
	if (error != B_OK)
		return error;

	// create ID table
	fTypesByID = new(std::nothrow) IDTable;
	if (fTypesByID == NULL)
		return B_NO_MEMORY;

	error = fTypesByID->Init();
	if (error != B_OK)
		return error;

	return B_OK;
}


Type*
GlobalTypeCache::GetType(const BString& name,
	const TypeLookupConstraints &constraints) const
{
	TypeEntry* typeEntry = fTypesByName->Lookup(name);
	if (typeEntry != NULL) {
		if (constraints.HasTypeKind()
			&& typeEntry->type->Kind() != constraints.TypeKind())
			typeEntry = NULL;
		else if (constraints.HasSubtypeKind()) {
			if (typeEntry->type->Kind() == TYPE_ADDRESS) {
					AddressType* type = dynamic_cast<AddressType*>(
						typeEntry->type);
					if (type == NULL)
						typeEntry = NULL;
					else if (type->AddressKind() != constraints.SubtypeKind())
						typeEntry = NULL;
			} else if (typeEntry->type->Kind() == TYPE_COMPOUND) {
					CompoundType* type = dynamic_cast<CompoundType*>(
						typeEntry->type);
					if (type == NULL)
						typeEntry = NULL;
					else if (type->CompoundKind() != constraints.SubtypeKind())
						typeEntry = NULL;
			}
		}
	}
	return typeEntry != NULL ? typeEntry->type : NULL;
}


Type*
GlobalTypeCache::GetTypeByID(const BString& id) const
{
	TypeEntry* typeEntry = fTypesByID->Lookup(id);
	return typeEntry != NULL ? typeEntry->type : NULL;
}


status_t
GlobalTypeCache::AddType(Type* type)
{
	const BString& id = type->ID();
	const BString& name = type->Name();

	if (fTypesByID->Lookup(id) != NULL
		|| (name.Length() > 0 && fTypesByID->Lookup(name) != NULL)) {
		return B_BAD_VALUE;
	}

	TypeEntry* typeEntry = new(std::nothrow) TypeEntry(type);
	if (typeEntry == NULL)
		return B_NO_MEMORY;

	fTypesByID->Insert(typeEntry);

	if (name.Length() > 0)
		fTypesByName->Insert(typeEntry);

	return B_OK;
}


void
GlobalTypeCache::RemoveType(Type* type)
{
	if (TypeEntry* typeEntry = fTypesByID->Lookup(type->ID())) {
		if (typeEntry->type == type) {
			fTypesByID->Remove(typeEntry);

			if (type->Name().Length() > 0)
				fTypesByName->Remove(typeEntry);

			delete typeEntry;
		}
	}
}


void
GlobalTypeCache::RemoveTypes(image_id imageID)
{
	AutoLocker<GlobalTypeCache> locker(this);

	for (IDTable::Iterator it = fTypesByID->GetIterator();
			TypeEntry* typeEntry = it.Next();) {
		if (typeEntry->type->ImageID() == imageID) {
			fTypesByID->RemoveUnchecked(typeEntry);

			if (typeEntry->type->Name().Length() > 0)
				fTypesByName->Remove(typeEntry);

			delete typeEntry;
		}
	}
}


// #pragma mark - GlobalTypeLookup


GlobalTypeLookup::~GlobalTypeLookup()
{
}