---

IgRepSet.cc

Go to the documentation of this file.

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

#include "Iguana/Framework/interface/IgRepSet.h"
#include "Iguana/Framework/interface/IgRepContext.h"
#include "Iguana/Framework/interface/IgBrowserMethods.h"
#include "Iguana/Framework/interface/IgRepresentable.h"

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

IgRepSet::LookupTable &
IgRepSet::table (void)
{
    static LookupTable table;
    return table;
}

IgRepSet::IgRepSet (IgRepresentable *object)
    : m_object (object),
      m_first (0)
{}

IgRepSet::~IgRepSet (void)
{
    VERIFY (table ().erase (m_object) == 1);

    // Get rid of contexts
    while (m_first)
        delete m_first;
}

void
IgRepSet::add (IgRepContext *context)
{
    ASSERT (context);
    ASSERT (context != m_first);

    if (! m_first)
    {
        context->chain (context);
        m_first = context;
    }
    else
    {
        IgRepContext *last = m_first;
        while (last->next () != m_first)
        {
            ASSERT (last->next () != context);
            last = last->next ();
        }
        context->chain (m_first);
        last->chain (context);
    }
}

void
IgRepSet::remove (IgRepContext *context)
{
    ASSERT (m_first);
    ASSERT (context);

    IgRepContext *previous = m_first;
    IgRepContext *pos = m_first->next ();

    while (pos != context)
    {
        ASSERT (pos);
        previous = pos;
        pos = pos->next ();
    }

    ASSERT (pos == context);
    ASSERT (previous->next () == context);

    IgRepContext *next = pos->next ();
    if (previous == context)
    {
        // the list is only context long, and `context' is its only element
        ASSERT (m_first == context);
        ASSERT (m_first->next () == m_first);
        m_first = 0;
    }
    else
    {
        // unchain this context
        previous->chain (next);
        if (m_first == context)
            m_first = next;
    }
    context->chain (0);
}

IgRepContext *
IgRepSet::lookup (IgModel *model) const
{
    ASSERT (model);

    IgRepContext *context = m_first;
    do {
        if (! context)
            return 0;

        if (context->model () == model)
            return context;

        context = context->next ();
    } while (context != m_first);

    return 0;
}

IgRepSet *
IgRepSet::associate (IgRepresentable *object, bool create /* = false */)
{
    LookupTable &lookup_table = table ();
    LookupTable::iterator pos = lookup_table.find (object);

    if (pos != lookup_table.end ())
    {
        ASSERT (pos->second);
        return pos->second;
    }
    else if (create)
    {
        IgRepSet *&set = lookup_table [object];
        set = new IgRepSet (object);
        return set;
    }
    else
        return 0;
}

IgRep *
IgRepSet::lookup (IgRepresentable *object, IgModel *model, bool create)
{
    IgRepSet     *set = IgRepSet::associate (object, create);
    IgRepContext *context = set ? set->lookup (model) : 0;

    if (! context && create)
        context = IgBrowserMethods::represent (object, model);

    return context ? context->rep () : 0;
}

IgRep *
IgRepSet::lookup (IgRepContext *context, IgModel *model, bool create)
{
    IgRepContext *other = context->next ();

    while (other != context && other->model () != model)
        other = other->next ();

    if (other->model () == model)
        return other->rep ();
    else if (create)
    {
        other = IgBrowserMethods::represent (context->object (), model);
        ASSERT (! other || other->model () == model);
        ASSERT (! other || other->rep ());

    }

    return other ? other->rep () : 0;
}

void
IgRepSet::update (IgRepresentable *object, unsigned field)
{
    // Check if the object has any representations
    IgRepSet *set = associate (object);
    if (! set)
        return;

    // Update all contexts
    IgRepContext *first = set->contexts ();
    IgRepContext *context = first;

    do
        IgBrowserMethods::update (object, context->rep (), field);
    while ((context = context->next ()) != first);
}

void
IgRepSet::update (IgRepContext *context, unsigned field)
{
    IgRepContext        *next = context->next ();
    IgRepresentable     *object = context->object ();

    for ( ; next != context; next = next->next ())
        IgBrowserMethods::update (object, next->rep (), field);
}

void
IgRepSet::update (IgRepresentable *object,IgModel *model, unsigned field)
{
    if (IgRep *rep = lookup (object, model, false))
        IgBrowserMethods::update (object, rep, field);
}

void
IgRepSet::invalidate (IgRepresentable *object, unsigned field)
{
    IgBrowserMethods::invalidate (object, 0, field);
}

void
IgRepSet::invalidate (IgRepContext *context, unsigned field)
{
    IgRepContext        *next = context->next ();
    IgRepresentable     *object = context->object ();

    for ( ; next != context; next = next->next ())
        IgBrowserMethods::invalidate (object, next->model (), field);
}

void
IgRepSet::invalidate (IgRepresentable *object, IgModel *model, unsigned field)
{
    IgBrowserMethods::invalidate (object, model, field);
}

---