---

IgState.cc

Go to the documentation of this file.

//<<<<<< INCLUDES                                                       >>>>>>

#include "Iguana/Framework/interface/IgState.h"
#include "Iguana/Framework/interface/IgStateKey.h"
#include "Iguana/Framework/interface/IgStateElement.h"
#include "classlib/utils/DebugAids.h"
#include <algorithm>

//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>

void
IgState::addChild (IgState *child)
{
    ASSERT (child);
    ASSERT (std::find (m_children.begin (), m_children.end (), child)
            == m_children.end ());

    m_children.push_back (child);
}

void
IgState::detachChild (IgState *child)
{
    ASSERT (child);
    Children::iterator pos
        = std::find (m_children.begin (), m_children.end (), child);

    ASSERT (pos != m_children.end ());

    m_children.erase (pos);
}


IgState::IgState (IgState *parent /* = 0 */)
    : m_parent (parent)
{ if (m_parent) m_parent->addChild (this); }

IgState::~IgState (void)
{
    if (m_parent)
        m_parent->detachChild (this);

    while (! m_children.empty ())
        delete m_children.front ();

    for (Elements::size_type i = 0; i < m_elements.size (); ++i)
        delete m_elements [i];
}


IgState *
IgState::root (void) const
{
    IgState *s = const_cast<IgState *> (this);
    while (s->m_parent)
        s = s->m_parent;

    return s;
}

IgState *
IgState::parent (void) const
{ return m_parent; }

unsigned
IgState::children (void) const
{ return m_children.size (); }

IgState *
IgState::child (unsigned index) const
{ ASSERT (index < m_children.size ()); return m_children [index]; }


IgStateElement *
IgState::get (IgStateKey index, IgState **context /* = 0 */) const
{
    IgState             *in = const_cast<IgState *> (this);
    IgStateElement      *element = 0;

    for ( ; in && ! element; in = in->parent ())
        if (index < in->m_elements.size ())
            element = in->m_elements [index];

    if (context)
        *context = in;

    return element;
}

void
IgState::put (IgStateKey index, IgStateElement *element)
{
    if (index >= m_elements.size ())
    {
        if (! element)
            return;
        else
            m_elements.resize (index+1, 0);
    }

    if (m_elements [index] != element)
    {
        // Destructor must call detach()
        delete m_elements [index];
        ASSERT (m_elements [index] == 0);
    }

    m_elements [index] = element;
}

void
IgState::erase (IgStateKey index)
{ put (index, 0); }

void
IgState::detach (IgStateKey index)
{
    ASSERT (index <= m_elements.size ());
    ASSERT (m_elements [index]);
    m_elements [index] = 0;
}

unsigned
IgState::elements (void) const
{ return m_elements.size (); }

IgStateElement *
IgState::element (unsigned index) const
{ ASSERT (index < m_elements.size ()); return m_elements [index]; }

---