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


#include "StackFrameValues.h"

#include <new>

#include "FunctionID.h"
#include "TypeComponentPath.h"


struct StackFrameValues::Key {
        ObjectID*                       variable;
        TypeComponentPath*      path;

        Key(ObjectID* variable, TypeComponentPath* path)
                :
                variable(variable),
                path(path)
        {
        }

        uint32 HashValue() const
        {
                return variable->HashValue() ^ path->HashValue();
        }

        bool operator==(const Key& other) const
        {
                return *variable == *other.variable && *path == *other.path;
        }
};


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

        ValueEntry(ObjectID* variable, TypeComponentPath* path)
                :
                Key(variable, path)
        {
                variable->AcquireReference();
                path->AcquireReference();
        }

        ~ValueEntry()
        {
                variable->ReleaseReference();
                path->ReleaseReference();
        }
};


struct StackFrameValues::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;
        }
};


StackFrameValues::StackFrameValues()
        :
        fValues(NULL)
{
}


StackFrameValues::StackFrameValues(const StackFrameValues& 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->variable, entry->path, entry->value) != B_OK)
                                throw std::bad_alloc();
                }
        } catch (...) {
                _Cleanup();
                throw;
        }
}


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


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

        return fValues->Init();
}


bool
StackFrameValues::GetValue(ObjectID* variable, const TypeComponentPath* path,
        BVariant& _value) const
{
        ValueEntry* entry = fValues->Lookup(
                Key(variable, (TypeComponentPath*)path));
        if (entry == NULL)
                return false;

        _value = entry->value;
        return true;
}


bool
StackFrameValues::HasValue(ObjectID* variable, const TypeComponentPath* path)
        const
{
        return fValues->Lookup(Key(variable, (TypeComponentPath*)path)) != NULL;
}


status_t
StackFrameValues::SetValue(ObjectID* variable, TypeComponentPath* path,
        const BVariant& value)
{
        ValueEntry* entry = fValues->Lookup(Key(variable, path));
        if (entry == NULL) {
                entry = new(std::nothrow) ValueEntry(variable, path);
                if (entry == NULL)
                        return B_NO_MEMORY;
                fValues->Insert(entry);
        }

        entry->value = value;
        return B_OK;
}


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

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

                delete fValues;
                fValues = NULL;
        }
}