void *DisplayDriver::init(){ void *xvrgldrv; if(drv != 0){ try{ drv->load(); //Load all exported symbols here __ddrv_init = (void *(*)())drv->getSymbol("__ddrv_init"); __ddrv_setresolution = (void (*)(void *, int, int))drv->getSymbol("__ddrv_setresolution"); __ddrv_getresolution = (void (*)(void *, int *, int *))drv->getSymbol("__ddrv_setresolution"); __ddrv_setdepth = (bool (*)(void *, int))drv->getSymbol("__ddrv_setdepth"); __ddrv_getdepth = (int (*)(void *))drv->getSymbol("__ddrv_getdepth"); __ddrv_width = (int (*)(void *))drv->getSymbol("__ddrv_width"); __ddrv_height = (int (*)(void *))drv->getSymbol("__ddrv_height"); __ddrv_open = (bool (*)(void *, int))drv->getSymbol("__ddrv_open"); __ddrv_close = (bool (*)(void *))drv->getSymbol("__ddrv_close"); __ddrv_swapbuffers = (bool (*)(void *))drv->getSymbol("__ddrv_swapbuffers"); __ddrv_setstereo = (bool (*)(void *, int))drv->getSymbol("__ddrv_setstereo"); __ddrv_getstereo = (bool (*)(void *))drv->getSymbol("__ddrv_getstereo"); __ddrv_getlasterror = (const char *(*)(void *))drv->getSymbol("__ddrv_getlasterror"); /*__ddrv_ = (void *(*)(void *))drv->getSymbol("__ddrv_"); __ddrv_ = (void *(*)(void *))drv->getSymbol("__ddrv_"); __ddrv_ = (void *(*)(void *))drv->getSymbol("__ddrv_");*/ xvrgldrv = __ddrv_init(); } catch(...){ throw; } } else{ throw NullPointer(); } return xvrgldrv; }
ModuleController & ModuleController::get_client_handle(const char *controller, const pegasus_identity & id, client_handle **handle) { if(handle == NULL) throw NullPointer(); Array<Uint32> services; MessageQueue *message_queue = MessageQueue::lookup(controller); if ((message_queue == NULL) || ( false == message_queue->isAsync() )) { throw IncompatibleTypesException(); } MessageQueueService *service = static_cast<MessageQueueService *>(message_queue); if( (service == NULL) || ! ( service->get_capabilities() & module_capabilities::module_controller )) { throw IncompatibleTypesException(); } ModuleController *_controller = static_cast<ModuleController *>(service); if(true == const_cast<pegasus_identity &>(id).authenticate()) *handle = new client_handle(id); else *handle = NULL; return *_controller; }
PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL slp_service_agent::service_listener(void *parm) { Thread *myself = (Thread *)parm; if(myself == 0) throw NullPointer(); slp_service_agent *agent = (slp_service_agent *)myself->get_parm(); lslpMsg msg_list; while(agent->_should_listen.value()) { Uint32 now, msec; System::getCurrentTime(now, msec); // now register everything for(slp_reg_table::Iterator i = agent->_internal_regs.start(); i ; i++) { sa_reg_params *rp = i.value(); if(rp->expire == 0 || rp->expire < now - 1) { rp->expire = now + rp->lifetime; if(agent->_using_das.value()) { agent->_rep->srv_reg_all( agent->_rep, rp->url, rp->attrs, rp->type, rp->scopes, rp->lifetime); } else { agent->_rep->srv_reg_local( agent->_rep, rp->url, rp->attrs, rp->type, rp->scopes, rp->lifetime); } } } agent->_rep->service_listener(agent->_rep, 0, &msg_list); _LSLP_SLEEP(1); } myself->exit_self((PEGASUS_THREAD_RETURN) 0) ; return(0); }
void Entidad::removerUnionARelacion(UnionEntidadRelacion *u) throw (NullPointer) { if (u == NULL) { throw NullPointer("Puntero nulo en removerUnionARelacion de Entidad"); } std::vector<UnionEntidadRelacion *>::iterator it_uniones; it_uniones = find(this->unionesARelacion.begin(), this->unionesARelacion.end(), u); if (it_uniones != this->unionesARelacion.end()) { this->unionesARelacion.erase(it_uniones); } }
void CQLParser::parse( const char* text, CQLSelectStatement& statement) { PEG_METHOD_ENTER(TRC_CQL,"CQLParser::parse"); AutoMutex mtx(CQL_mutex); if (!text) { PEG_METHOD_EXIT(); throw NullPointer(); } statement.clear(); CQL_restart (0); CQL_globalParserState = new CQLParserState; CQL_globalParserState->error = false; CQL_globalParserState->text = text; CQL_globalParserState->textSize = (Uint32)(strlen(text) + 1); CQL_globalParserState->offset = 0; CQL_globalParserState->currentTokenPos = 0; CQL_globalParserState->tokenCount = 0; CQL_globalParserState->currentRule = String::EMPTY; CQL_globalParserState->statement = &statement; try { CQL_parse(); } catch(...) { CQL_Bison_Cleanup(); delete CQL_globalParserState; PEG_METHOD_EXIT(); throw; } if (CQL_globalParserState->error) { String errorMessage = CQL_globalParserState->errorMessage; cleanup(); Uint32 position = CQL_globalParserState->currentTokenPos; Uint32 token = CQL_globalParserState->tokenCount; String rule = CQL_globalParserState->currentRule; delete CQL_globalParserState; PEG_METHOD_EXIT(); throw CQLSyntaxErrorException(errorMessage,token,position,rule); } cleanup(); delete CQL_globalParserState; PEG_METHOD_EXIT(); }
void Jerarquia::quitarEntidadEspecializada(EntidadNueva * entidadEspecializada) throw (NullPointer) { if (entidadEspecializada == NULL) { throw NullPointer("Puntero nulo en quitarEntidadEspecializada en Jerarquia"); } std::vector<EntidadNueva *>::iterator it_entidad; it_entidad = find(this->entidadesEspecializadas.begin(), this->entidadesEspecializadas.end(), entidadEspecializada); if (it_entidad != this->entidadesEspecializadas.end()) { this->entidadesEspecializadas.erase(it_entidad); } }
/** * @brief CreateArray * @param numTuples * @param compDims * @param name * @param allocate * @return */ static Pointer CreateArray(size_t numTuples, QVector<size_t> compDims, const QString& name, bool allocate = true) { if (name.isEmpty() == true) { return NullPointer(); } StringDataArray* d = new StringDataArray(numTuples, name, allocate); d->setName(name); Pointer ptr(d); return ptr; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- StatsDataArray::Pointer StatsDataArray::CreateArray(size_t numTuples, int rank, size_t* dims, const QString& name, bool allocate) { if (name.isEmpty() == true) { return NullPointer(); } StatsDataArray::Pointer ptr = StatsDataArray::New(); ptr->setName(name); std::vector<unsigned int> phase_types(numTuples, DREAM3D::PhaseType::UnknownPhaseType); if(allocate) { ptr->fillArrayWithNewStatsData(numTuples, &(phase_types.front()) ); } return ptr; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- VertexGeom::Pointer VertexGeom::CreateGeometry(int64_t numVertices, const QString& name) { if (name.isEmpty() == true) { return NullPointer(); } SharedVertexList::Pointer vertices = VertexGeom::CreateSharedVertexList(numVertices); VertexGeom* d = new VertexGeom(); d->setVertices(vertices); d->setName(name); Pointer ptr(d); return ptr; }
void Console::outWrite(const void *buf, UInt32 siz){ if(out != 0){ //__conm.lock(); try{ out->write(buf, siz); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
void Console::readLine(String &line){ if(in != 0){ //__conm.lock(); try{ in->readLine(line); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
void Console::read(void *buf, UInt32 size){ if(in != 0){ //__conm.lock(); try{ in->read(buf, size); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
void Console::errWriteLine(const String& text){ if(err != 0){ //__conm.lock(); try{ err->writeLine(text.toCharPtr(), text.size()); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
void Console::errWriteLine(const void *buf, UInt32 siz){ if(err != 0){ //__conm.lock(); try{ err->writeLine(buf, siz); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
void Console::outWrite(const String &text) const { if(out != 0){ //__conm.lock(); try{ out->write(text.toCharPtr(), text.size()); } catch(...){ //__conm.unlock(); throw; } //__conm.unlock(); } else throw NullPointer(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QuadGeom::Pointer QuadGeom::CreateGeometry(int64_t numQuads, SharedVertexList::Pointer vertices, const QString& name) { if (name.isEmpty() == true) { return NullPointer(); } SharedQuadList::Pointer quads = QuadGeom::CreateSharedQuadList(numQuads); QuadGeom* d = new QuadGeom(); d->setVertices(vertices); d->setQuads(quads); d->setName(name); Pointer ptr(d); return ptr; }
/** * @brief Static constructor * @param numElements The number of elements in the internal array. * @param name The name of the array * @return Boost::Shared_Ptr wrapping an instance of DataArrayTemplate<T> */ static Pointer CreateArray(size_t numElements, const std::string &name) { if (name.empty() == true) { return NullPointer(); } DataArray<T>* d = new DataArray<T> (numElements, true); if (d->Allocate() < 0) { // Could not allocate enough memory, reset the pointer to null and return delete d; return DataArray<T>::NullPointer(); } d->SetName(name); Pointer ptr(d); return ptr; }
void MessageQueueService::enumerate_service(Uint32 queue, message_module *result) { if (result == 0) { throw NullPointer(); } EnumerateService *req = new EnumerateService( get_next_xid(), 0, _queueId, true, queue); AsyncMessage *reply = SendWait(req); if (reply) { Boolean found = false; if (reply->getMask() & message_mask::ha_async) { if (reply->getMask() & message_mask::ha_reply) { if (reply->getType() == async_messages::ENUMERATE_SERVICE_RESULT) { if ((static_cast<EnumerateServiceResponse *>(reply))->result == async_results::OK) { if (found == false) { found = true; result->put_name((static_cast<EnumerateServiceResponse *>(reply))->name); result->put_capabilities((static_cast<EnumerateServiceResponse *>(reply))->capabilities); result->put_mask((static_cast<EnumerateServiceResponse *>(reply))->mask); result->put_queue((static_cast<EnumerateServiceResponse *>(reply))->qid); } } } } } delete reply; } delete req; return; }
void MessageQueue::enqueue(Message* message) { PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::enqueue()"); if (!message) { Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3, "MessageQueue::enqueue failure"); PEG_METHOD_EXIT(); throw NullPointer(); } PEG_TRACE_STRING( TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3, String("Queue name: ") + getQueueName() ) ; Tracer::trace ( TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3, "Message: [%s, %d]", MessageTypeToString(message->getType()), message->getKey() ); { AutoMutex autoMut(_mut); if (_back) { _back->_next = message; message->_prev = _back; message->_next = 0; _back = message; } else { _front = message; _back = message; message->_prev = 0; message->_next = 0; } message->_owner = this; _count++; Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4, "MessageQueue::enqueue _queueId = %d, _count = %d", _queueId, _count); } // mutex unlocks here handleEnqueue(); PEG_METHOD_EXIT(); }
void Regex::compile(){ regex_t *r; int ret; if(handle == 0){ r = new regex_t; handle = (void *)r; } else{ r = (regex_t *)handle; } if(_pattern == 0) throw NullPointer(); ret = regcomp(r, _pattern->toCharPtr(), cflags); if(ret != 0){ throw RegexException(ret); } compiled = true; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- StatsDataArray::Pointer StatsDataArray::CreateArray(QVector<size_t> tDims, QVector<size_t> cDims, const QString& name, bool allocate) { if (name.isEmpty() == true) { return NullPointer(); } size_t numTuples = tDims[0]; qint32 size = tDims.size(); for(qint32 iter = 1; iter < size; iter++) { numTuples *= tDims[iter]; } StatsDataArray::Pointer ptr = StatsDataArray::New(); ptr->setName(name); std::vector<unsigned int> phase_types(numTuples, DREAM3D::PhaseType::UnknownPhaseType); if(allocate) { ptr->fillArrayWithNewStatsData(numTuples, &(phase_types.front()) ); } return ptr; }
void MessageQueueService::find_services( String name, Uint32 capabilities, Uint32 mask, Array<Uint32> *results) { if (results == 0) { throw NullPointer(); } results->clear(); FindServiceQueue *req = new FindServiceQueue( get_next_xid(), 0, _queueId, true, name, capabilities, mask); req->dest = CIMOM_Q_ID; AsyncMessage *reply = SendWait(req); if (reply) { if (reply->getMask() & message_mask::ha_async) { if (reply->getMask() & message_mask::ha_reply) { if (reply->getType() == async_messages::FIND_SERVICE_Q_RESULT) { if ((static_cast<FindServiceQueueResult *>(reply))->result == async_results::OK) *results = (static_cast<FindServiceQueueResult *>(reply))->qids; } } } delete reply; } delete req; return ; }
/** * @brief Static constructor * @param numTuples The number of tuples in the array. * @param dims The actual dimensions of the attribute on each Tuple * @param name The name of the array * @return Boost::Shared_Ptr wrapping an instance of DataArrayTemplate<T> */ static Pointer CreateArray(size_t numTuples, QVector<size_t> cDims, const QString& name, bool allocate = true) { if (name.isEmpty() == true) { return NullPointer(); } DataArray<T>* d = new DataArray<T>(numTuples, cDims, name, allocate); if(allocate) { if (d->allocate() < 0) { // Could not allocate enough memory, reset the pointer to null and return delete d; return DataArray<T>::NullPointer(); } } Pointer ptr(d); return ptr; }
void MessageQueue::remove(Message* message) { PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::remove()"); if (!message) { PEG_METHOD_EXIT(); throw NullPointer(); } if (message->_owner != this) { PEG_METHOD_EXIT(); throw NoSuchMessageOnQueue(); } { AutoMutex autoMut(_mut); if (message->_next) message->_next->_prev = message->_prev; else _back = message->_prev; if (message->_prev) message->_prev->_next = message->_next; else _front = message->_next; _count--; Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4, "MessageQueue::remove _count = %d", _count); } // mutex unlocks here message->_prev = 0; message->_next = 0; message->_owner = 0; PEG_METHOD_EXIT(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QuadGeom::Pointer QuadGeom::CreateGeometry(SharedQuadList::Pointer quads, SharedVertexList::Pointer vertices, const QString& name) { if (name.isEmpty() == true) { return NullPointer(); } if (vertices.get() == NULL) { return QuadGeom::NullPointer(); } if (quads.get() == NULL) { return QuadGeom::NullPointer(); } QuadGeom* d = new QuadGeom(); d->setVertices(vertices); d->setQuads(quads); d->setName(name); Pointer ptr(d); return ptr; }
MessageQueue* MessageQueue::lookup(const char *name) { if (name == NULL) throw NullPointer(); AutoMutex autoMut(q_table_mut); for (QueueTable::Iterator i = _queueTable.start(); i; i++) { // ATTN: Need to decide how many characters to compare in queue names if (!strcmp(((MessageQueue *)i.value())->getQueueName(), name)) { return (MessageQueue *)i.value(); } } PEG_TRACE((TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL1, "MessageQueue::lookup failure - name = %s", name)); return 0; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- TriangleGeom::Pointer TriangleGeom::CreateGeometry(SharedTriList::Pointer triangles, SharedVertexList::Pointer vertices, const QString& name) { if (name.isEmpty() == true) { return NullPointer(); } if (vertices.get() == NULL) { return TriangleGeom::NullPointer(); } if (triangles.get() == NULL) { return TriangleGeom::NullPointer(); } TriangleGeom* d = new TriangleGeom(); d->setVertices(vertices); d->setTriangles(triangles); d->setName(name); Pointer ptr(d); return ptr; }
Sint32 JMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret) { static Uint32 quantum; PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl"); Sint32 ccode = 0; CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm); switch(code) { case GET_PROVIDER: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::GET_PROVIDER"); String providerName = *(parms->providerName); String moduleFileName = *(parms->fileName); String interfaceName = *(parms->interfaceName); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: GET_PROVIDER " <<providerName <<PEGASUS_STD(endl)); JMPIProvider::OpProviderHolder* ph = reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret ); JMPIProviderModule *newModule = NULL; JMPIProviderModule *module = NULL; JMPIProvider *newProvider = NULL; JMPIProvider *provider = NULL; ProviderVector base; try { { AutoMutex lock (_providerTableMutex); if (true == _providers.lookup(providerName, provider)) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Found JMPIProvider " + providerName + " in JMPIProvider Manager Cache"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: Found " <<providerName <<" in JMPIProvider Manager Cache" <<PEGASUS_STD(endl)); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " setting provider to " <<PEGASUS_STD(hex) <<(int)provider <<PEGASUS_STD(dec) <<PEGASUS_STD(endl)); ph->SetProvider(provider); //////////////////////ph->GetProvider().update_idle_timer(); break; } PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Creating JMPIProvider " + providerName ); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: Creating " <<providerName <<PEGASUS_STD(endl)); if (false == _modules.lookup(moduleFileName, module)) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Creating JMPIProvider Module " + moduleFileName ); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "Creating module " <<moduleFileName <<PEGASUS_STD(endl)); newModule = new JMPIProviderModule(moduleFileName, interfaceName); if (0 == newModule) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "new JMPIProviderModule is NULL!"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " new JMPIProviderModule is NULL!" <<PEGASUS_STD(endl)); throw NullPointer(); } module = newModule; _modules.insert(moduleFileName, module); } else { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Using Cached JMPIProvider Module " + moduleFileName); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "Using cached " <<moduleFileName <<PEGASUS_STD(endl)); } } PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Loading/Linking JMPIProvider Module " + moduleFileName ); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " Loading/Linking module " <<moduleFileName <<PEGASUS_STD(endl)); try { base = module->load(moduleFileName); } catch(...) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Exception caught Loading/Linking" " JMPIProvider Module " + moduleFileName ); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "Exception caught Loading/Linking module " <<moduleFileName <<PEGASUS_STD(endl)); throw; } // create provider module newProvider = new JMPIProvider(providerName, module, &base); if (0 == newProvider) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "new JMPIProvider is NULL!"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "new JMPIProvider is NULL!" <<PEGASUS_STD(endl)); throw NullPointer(); } provider = newProvider; if (0 == (provider->_cimom_handle = new CIMOMHandle())) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "_cimom_handle is NULL!"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " _cimom_handle is NULL!" <<PEGASUS_STD(endl)); throw NullPointer(); } provider->_quantum = 0; { AutoMutex lock(provider->_statusMutex); PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "Loading JMPIProvider " + provider->_name); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " Loading " <<provider->_name <<PEGASUS_STD(endl)); try { provider->initialize(*(provider->_cimom_handle)); } catch(...) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Exception caught calling initialize!"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" " Exception caught calling initialize!" <<PEGASUS_STD(endl)); throw UninitializedObjectException(); } } } catch (...) { if (newModule) { _modules.remove(moduleFileName); } delete newModule; if (newProvider) { delete newProvider->_cimom_handle; } delete newProvider; throw; } // provider->update_idle_timer(); _providers.insert(providerName, provider); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl:" "setting provider to " <<PEGASUS_STD(hex) <<(int)provider <<PEGASUS_STD(dec) <<PEGASUS_STD(endl)); ph->SetProvider( provider ); break; } case UNLOAD_PROVIDER: { DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "UNLOAD_PROVIDER" <<PEGASUS_STD(endl)); break; } case LOOKUP_PROVIDER: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::LOOKUP_PROVIDER"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "LOOKUP_PROVIDER " <<*(parms->providerName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if (true == _providers.lookup(*(parms->providerName), *(reinterpret_cast<JMPIProvider * *>(ret)))) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Found JMPIProvider in cache: " + *(parms->providerName)); ////////////////(*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer(); } else { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Could not find JMPIProvider in cache: " + *(parms->providerName)); ccode = -1; } break; } case LOOKUP_MODULE: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::LOOKUP_MODULE"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "LOOKUP_MODULE " <<*(parms->fileName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if (false == _modules.lookup(*(parms->fileName), *(reinterpret_cast<JMPIProviderModule * *>(ret)))) { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Could not find JMPIProvider Module in cache: " + *(parms->fileName)); ccode = -1; } break; } case INSERT_PROVIDER: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::INSERT_PROVIDER"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "INSERT_PROVIDER " <<*(parms->providerName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if (false == _providers.insert(*(parms->providerName), *reinterpret_cast<JMPIProvider * *>(parm))) ccode = -1; break; } case INSERT_MODULE: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::INSERT_MODULE"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "INSERT_MODULE " <<*(parms->fileName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if(false == _modules.insert(*(parms->fileName), *reinterpret_cast<JMPIProviderModule * *>(parm))) ccode = -1; break; } case REMOVE_PROVIDER: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::REMOVE_PROVIDER"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "REMOVE_PROVIDER " <<*(parms->providerName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if (false == _providers.remove(*(parms->providerName))) ccode = -1; break; } case REMOVE_MODULE: { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, "_provider_ctrl::REMOVE_MODULE"); DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: REMOVE_MODULE " <<*(parms->fileName) <<PEGASUS_STD(endl)); AutoMutex lock (_providerTableMutex); if (false == _modules.remove(*(parms->fileName))) ccode = -1; break; } case UNLOAD_ALL_PROVIDERS: { DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "UNLOAD_ALL_PROVIDERS" <<PEGASUS_STD(endl)); JMPIjvm::destroyJVM(); break; } case UNLOAD_IDLE_PROVIDERS: { DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "UNLOAD_IDLE_PROVIDERS" <<PEGASUS_STD(endl)); break; } case UNLOAD_IDLE_MODULES: { DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: " "UNLOAD_IDLE_MODULES" <<PEGASUS_STD(endl)); break; } default: { DDD(PEGASUS_STD(cout) <<"--- JMPILocalProviderManager::_provider_ctrl: unknown! " <<code <<PEGASUS_STD(endl)); ccode = -1; break; } } PEG_METHOD_EXIT(); return(ccode); }
void Jerarquia::agregarEntidadEspecializada(EntidadNueva * entidadEspecializada) throw (NullPointer) { if (entidadEspecializada == NULL) { throw NullPointer("Puntero nulo en agregarEntidadEspecializada en Jerarquia"); } this->entidadesEspecializadas.push_back(entidadEspecializada); }
void Jerarquia::setEntidadGeneral(Entidad * entidadGeneral) throw (NullPointer) { if (entidadGeneral == NULL) { throw NullPointer("Puntero nulo en setEntidadGeneral en Jerarquia"); } this->entidadGeneral = entidadGeneral; }