haiku.git

/*
 * Copyright 2014-2016, Rene Gollent, rene@gollent.com.
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "ExpressionValues.h"

#include <new>

#include "FunctionID.h"
#include "model/Thread.h"


struct ExpressionValues::Key {
	FunctionID*			function;
	::Thread*			thread;
	BString				expression;

	Key(FunctionID* function, ::Thread* thread, const BString& expression)
		:
		function(function),
		thread(thread),
		expression(expression)
	{
	}

	uint32 HashValue() const
	{
		return function->HashValue() ^ thread->ID()
			^ expression.HashValue();
	}

	bool operator==(const Key& other) const
	{
		return *function == *other.function
			&& thread->ID() == other.thread->ID()
			&& expression == other.expression;
	}
};


struct ExpressionValues::ValueEntry : Key {
	BVariant			value;
	ValueEntry*			next;

	ValueEntry(FunctionID* function, ::Thread* thread,
		const BString& expression)
		:
		Key(function, thread, expression)
	{
		function->AcquireReference();
		thread->AcquireReference();
	}

	~ValueEntry()
	{
		function->ReleaseReference();
		thread->ReleaseReference();
	}
};


struct ExpressionValues::ValueEntryHashDefinition {
	typedef Key			KeyType;
	typedef	ValueEntry	ValueType;

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

	size_t Hash(const ValueEntry* value) const
	{
		return value->HashValue();
	}

	bool Compare(const Key& key, const ValueEntry* value) const
	{
		return key == *value;
	}

	ValueEntry*& GetLink(ValueEntry* value) const
	{
		return value->next;
	}
};


ExpressionValues::ExpressionValues()
	:
	fValues(NULL)
{
}


ExpressionValues::ExpressionValues(const ExpressionValues& other)
	:
	fValues(NULL)
{
	try {
		// init
		if (Init() != B_OK)
			throw std::bad_alloc();

		// clone all values
		for (ValueTable::Iterator it = other.fValues->GetIterator();
				ValueEntry* entry = it.Next();) {
			if (SetValue(entry->function, entry->thread, entry->expression,
				entry->value) != B_OK) {
				throw std::bad_alloc();
			}
		}
	} catch (...) {
		_Cleanup();
		throw;
	}
}


ExpressionValues::~ExpressionValues()
{
	_Cleanup();
}


status_t
ExpressionValues::Init()
{
	fValues = new(std::nothrow) ValueTable;
	if (fValues == NULL)
		return B_NO_MEMORY;

	return fValues->Init();
}


bool
ExpressionValues::GetValue(FunctionID* function, ::Thread* thread,
	const BString* expression, BVariant& _value) const
{
	ValueEntry* entry = fValues->Lookup(Key(function, thread, *expression));
	if (entry == NULL)
		return false;

	_value = entry->value;
	return true;
}


bool
ExpressionValues::HasValue(FunctionID* function, ::Thread* thread,
	const BString* expression) const
{
	return fValues->Lookup(Key(function, thread, *expression)) != NULL;
}


status_t
ExpressionValues::SetValue(FunctionID* function, ::Thread* thread,
	const BString& expression, const BVariant& value)
{
	ValueEntry* entry = fValues->Lookup(Key(function, thread, expression));
	if (entry == NULL) {
		entry = new(std::nothrow) ValueEntry(function, thread, expression);
		if (entry == NULL)
			return B_NO_MEMORY;
		fValues->Insert(entry);
	}

	entry->value = value;
	return B_OK;
}


void
ExpressionValues::_Cleanup()
{
	if (fValues != NULL) {
		ValueEntry* entry = fValues->Clear(true);

		while (entry != NULL) {
			ValueEntry* next = entry->next;
			delete entry;
			entry = next;
		}

		delete fValues;
		fValues = NULL;
	}
}