void
IceInternal::ObjectFactoryManager::destroy()
{
    FactoryMap oldMap;
    {
        IceUtil::Mutex::Lock sync(*this);
        oldMap.swap(_factoryMap);
        _factoryMapHint = _factoryMap.end();
    }

    //
    // Destroy all outside lock
    //
    for_each(oldMap.begin(), oldMap.end(),
             Ice::secondVoidMemFun<const string, ObjectFactory>(&ObjectFactory::destroy));
}
Example #2
0
void
IcePy::ValueFactoryManager::destroy()
{
    AdoptThread adoptThread; // Ensure the current thread is able to call into Python.

    FactoryMap factories;

    {
        Lock lock(*this);
        if(_self == 0)
        {
            //
            // Nothing to do if already destroyed (this can occur if communicator destroy is called multiple times)
            //
            return;
        }
        //
        // Break the cyclic reference.
        //
        Py_DECREF(_self);
        _self = 0;

        factories.swap(_factories);
    }

    for(FactoryMap::iterator p = factories.begin(); p != factories.end(); ++p)
    {
        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(p->second);
        if(w)
        {
            w->destroy();
        }
    }

    _defaultFactory->destroy();
}
Example #3
0
void
IceRuby::ValueFactoryManager::destroy()
{
    FactoryMap factories;

    {
        Lock lock(*this);

        factories.swap(_factories);

        _self = Qnil;
    }

    for(FactoryMap::iterator p = factories.begin(); p != factories.end(); ++p)
    {
        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(p->second);
        if(w)
        {
            w->destroy();
        }
    }

    _defaultFactory->destroy();
}