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


#include "ValueNodeContainer.h"

#include <AutoLocker.h>

#include "ValueNode.h"


// #pragma mark - ValueNodeContainer


ValueNodeContainer::ValueNodeContainer()
        :
        fLock("value node container"),
        fChildren(20),
        fListeners(20)
{
}


ValueNodeContainer::~ValueNodeContainer()
{
        RemoveAllChildren();
        fListeners.MakeEmpty();
}


status_t
ValueNodeContainer::Init()
{
        return fLock.InitCheck();
}


int32
ValueNodeContainer::CountChildren() const
{
        return fChildren.CountItems();
}


ValueNodeChild*
ValueNodeContainer::ChildAt(int32 index) const
{
        return fChildren.ItemAt(index);
}


bool
ValueNodeContainer::AddChild(ValueNodeChild* child)
{
        AutoLocker<ValueNodeContainer> locker(this);

        if (!fChildren.AddItem(child))
                return false;

        child->AcquireReference();
        child->SetContainer(this);

        return true;
}


void
ValueNodeContainer::RemoveChild(ValueNodeChild* child)
{
        if (child->Container() != this || !fChildren.RemoveItem(child))
                return;

        child->SetNode(NULL);
        child->SetContainer(NULL);
        child->ReleaseReference();
}


void
ValueNodeContainer::RemoveAllChildren()
{
        for (int32 i = 0; ValueNodeChild* child = ChildAt(i); i++) {
                child->SetNode(NULL);
                child->SetContainer(NULL);
                child->ReleaseReference();
        }

        fChildren.MakeEmpty();
}


bool
ValueNodeContainer::AddListener(Listener* listener)
{
        return fListeners.AddItem(listener);
}


void
ValueNodeContainer::RemoveListener(Listener* listener)
{
        fListeners.RemoveItem(listener);
}


void
ValueNodeContainer::NotifyValueNodeChanged(ValueNodeChild* nodeChild,
        ValueNode* oldNode, ValueNode* newNode)
{
        for (int32 i = fListeners.CountItems() - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ValueNodeChanged(nodeChild, oldNode, newNode);
}


void
ValueNodeContainer::NotifyValueNodeChildrenCreated(ValueNode* node)
{
        for (int32 i = fListeners.CountItems() - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ValueNodeChildrenCreated(node);
}


void
ValueNodeContainer::NotifyValueNodeChildrenDeleted(ValueNode* node)
{
        for (int32 i = fListeners.CountItems() - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ValueNodeChildrenDeleted(node);
}


void
ValueNodeContainer::NotifyValueNodeValueChanged(ValueNode* node)
{
        for (int32 i = fListeners.CountItems() - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ValueNodeValueChanged(node);
}


// #pragma mark - ValueNodeContainer


ValueNodeContainer::Listener::~Listener()
{
}


void
ValueNodeContainer::Listener::ValueNodeChanged(ValueNodeChild* nodeChild,
        ValueNode* oldNode, ValueNode* newNode)
{
}


void
ValueNodeContainer::Listener::ValueNodeChildrenCreated(ValueNode* node)
{
}


void
ValueNodeContainer::Listener::ValueNodeChildrenDeleted(ValueNode* node)
{
}


void
ValueNodeContainer::Listener::ValueNodeValueChanged(ValueNode* node)
{
}