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;
}
