void Checkpoint::getComponentEvents (ComponentEventPtrArray & aList,
                                     std::set<string> *       aFilter)
{
    map<string, ComponentEventPtr *>::iterator it;

    for ( it = mEvents.begin( ); it != mEvents.end( ); ++it )
    {
        ComponentEventPtr e = *( ( *it ).second );

        if ( ( aFilter == NULL ) || ( ( e.getObject( ) != NULL ) && ( aFilter->count(e->getDataItem( )->getId( )) > 0 ) ) )
        {
            while ( e.getObject( ) != NULL )
            {
                ComponentEventPtr p = e->getPrev( );
                aList.push_back(e);
                e = p;
            }
        }
    }
}
void Checkpoint::addComponentEvent (ComponentEvent *anEvent)
{
    if ( mHasFilter )
    {
        if ( mFilter.count(anEvent->getDataItem( )->getId( )) == 0 )
        {
            return;
        }
    }

    DataItem *         item = anEvent->getDataItem( );
    string             id   = item->getId( );
    ComponentEventPtr *ptr  = mEvents[id];

    if ( ptr != NULL )
    {
        bool assigned = false;

        if ( item->isCondition( ) )
        {
            // Chain event only if it is normal or unavailable and the
            // previous condition was not normal or unavailable
            if ( ( ( *ptr )->getLevel( ) != ComponentEvent::NORMAL ) &&
                 ( anEvent->getLevel( ) != ComponentEvent::NORMAL ) &&
                 ( ( *ptr )->getLevel( ) != ComponentEvent::UNAVAILABLE ) &&
                 ( anEvent->getLevel( ) != ComponentEvent::UNAVAILABLE )
                 )
            {
                // Check to see if the native code matches an existing
                // active condition
                ComponentEvent *e = ( *ptr )->find(anEvent->getCode( ));

                if ( e != NULL )
                {
                    // Replace in chain.
                    ComponentEvent *n = ( *ptr )->deepCopyAndRemove(e);

                    // Check if this is the only event...
                    ( *ptr ) = n;

                    if ( n != NULL )
                    {
                        n->unrefer( );
                    }
                }

                // Chain the event
                if ( ptr->getObject( ) != NULL )
                {
                    anEvent->appendTo(*ptr);
                }
            }
            else if ( anEvent->getLevel( ) == ComponentEvent::NORMAL )
            {
                // Check for a normal that clears an active condition by code
                if ( anEvent->getCode( )[0] != '\0' )
                {
                    ComponentEvent *e = ( *ptr )->find(anEvent->getCode( ));

                    if ( e != NULL )
                    {
                        // Clear the one condition by removing it from the chain
                        ComponentEvent *n = ( *ptr )->deepCopyAndRemove(e);
                        ( *ptr ) = n;

                        if ( n != NULL )
                        {
                            n->unrefer( );
                        }
                        else
                        {
                            // Need to put a normal event in with no code since this
                            // is the last one.
                            n = new ComponentEvent(*anEvent);
                            n->normal( );
                            ( *ptr ) = n;
                            n->unrefer( );
                        }
                    }
                    else
                    {
                        // Not sure if we should register code specific normals if
                        // previous normal was not found
                        // (*ptr) = anEvent;
                    }
                    assigned = true;
                }
            }
        }

        if ( !assigned )
        {
            ( *ptr ) = anEvent;
        }
    }
    else
    {
        mEvents[id] = new ComponentEventPtr(anEvent);
    }
}