---

IgStateKey.cc

Go to the documentation of this file.

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

#include "Iguana/Framework/interface/IgStateKey.h"
#include "classlib/utils/DebugAids.h"

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

unsigned IgStateKey::s_count = 0;

//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>

IgStateKeyDef::IgStateKeyDef (const std::string &label)
    : IgStateKey (create (label)),
      m_label (label)
{}

IgStateKeyDef::~IgStateKeyDef (void)
{ remove (m_label); }


IgStateKey::IgStateKey (unsigned value)
    : m_value (value)
{}

std::string
IgStateKey::label (void) const
{
    Map &keys = keymap ();
    for (Map::iterator pos = keys.begin (); pos != keys.end (); ++pos)
        if (pos->second == m_value)
            return pos->first;

    // This can occur for the unknown key (~0U, see #index())
    return "<UNDEFINED>";
}


IgStateKey::Map &
IgStateKey::keymap (void)
{
    static char buf [sizeof (Map)];
    static Map  *bufmap = new (buf) Map;
    return *bufmap;
}

unsigned
IgStateKey::create (const std::string &label)
{
    // FIXME: Thread safety.

    // The logic here accommodates for keys that are getting recreated
    // due to dynamic loading and unloading of a library.  Once a key
    // has been created, we always keep it in the same index.  If the
    // library is unloaded, we keep the key in the dictionary but mark
    // it unused by turning on the 32nd (~ top) bit.  If the library
    // is subsequently re-loaded, we give it the same index back and
    // turn the bit off to indicate the index is in use again.
    ASSERT (! label.empty ());
    Map &keys = keymap ();
    if (! keys.count (label))
    {
        // Not seen this one before.  Allocate a new index for this.
        // Make sure we don't overrun to the area of our mark bits (if
        // this triggers, we'll be screwed anyway as we have far too
        // many state elements by then in every state).
        ASSERT (s_count < 0x8000000);
        unsigned value = s_count++;
        keys [label] = value;
        return value;
    }
    else
    {
        // We've seen this before.  Make sure the key index is not
        // active and then give it back.
        ASSERT (keys [label] & 0x8000000);
        unsigned &value = keys [label];
        value &= ~0x8000000;
        return value;
    }
}

void
IgStateKey::remove (const std::string &label)
{
    // See comments in #create() for the logic.  FIXME: Thread safety.
    ASSERT (! label.empty ());
    Map &keys = keymap ();
    ASSERT (keys.count (label));
    ASSERT (! (keys [label] & 0x8000000));
    keys [label] |= 0x8000000;
}

IgStateKey
IgStateKey::index (const std::string &label)
{
    // FIXME: Thread safety.
    ASSERT (! label.empty ());
    Map           &keys = keymap ();
    Map::iterator pos = keys.find (label);
    return pos == keys.end () ? ~0U : pos->second;
}

---