00001
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "SoapCorba.h"
00025 #include "BridgeStub.h"
00026 #include "DbObjects.h"
00027 #include "ReadIR.h"
00028 #include "RecurStop.h"
00029 #include "anyconfig/AnyConfig.h"
00030
00032 IRPLUS_H initIRPlus (CORBA_H cbaHdl, ANYCFG_H cfgHdl)
00033 {
00034 CORBA::ORB_ptr orb = (CORBA::ORB_ptr) cbaHdl;
00035 IRPlus *pirp = new IRPlus (orb);
00036 JTCSynchronized synchronized (pirp->monitor);
00037 AnyConfig::AcConfiguration *pCfg = (AnyConfig::AcConfiguration *) cfgHdl;
00038 pirp->pCon = new DOConnection;
00039 pCfg->getSectionStr ("irplus", "database", pirp->pCon->m_database);
00040 pCfg->getSectionStr ("irplus", "hostname", pirp->pCon->m_hostname);
00041 pCfg->getSectionStr ("irplus", "username", pirp->pCon->m_username);
00042 pCfg->getSectionStr ("irplus", "password", pirp->pCon->m_password);
00043 pirp->pCon->Connect ();
00044 if (!pirp->Init ()) return pirp;
00045 delete pirp;
00046 return NULL;
00047 }
00048
00050 void termIRPlus (IRPLUS_H hdl)
00051 {
00052 IRPlus *pirp = (IRPlus *) hdl;
00053 JTCSynchronized synchronized (pirp->monitor);
00054
00055 delete pirp;
00056 }
00057
00067 const char *iterIRPlus (IRPLUS_H hdl, IRP_ITEM_H *itm)
00068 {
00069 IRPlus *pirp = (IRPlus *) hdl;
00070 JTCSynchronized synchronized (pirp->monitor);
00071 SCInterfaceMethod *pMeth;
00072 if (!*itm) {
00073 pMeth = pirp->IRC.GetFirstInterfaceMethod ();
00074 } else {
00075 pMeth = (SCInterfaceMethod *) *itm;
00076 pMeth = pirp->IRC.GetNextInterfaceMethod (pMeth);
00077 }
00078 if (pMeth) {
00079 *itm = pMeth;
00080 return ((const char *) pMeth->m_mthPath) + 1;
00081 }
00082 *itm = NULL;
00083 return NULL;
00084 }
00085
00087 static void Add_IR_Comment (CString &xml, const char *kindName, CORBA::TypeCode_ptr tcp)
00088 {
00089 CString rem;
00090 CORBA::String_var name = tcp->name ();
00091 CORBA::String_var id = tcp->id ();
00092 rem.Format ("<!-- %s %s (%s) -->", kindName, (char *) name, (char *) id);
00093 xml += rem;
00094 }
00095
00103 void RecurseFields (CString &xml, TypeCodeList *tlist, CORBA::TypeCode_ptr tcp)
00104 {
00105 switch (tcp->kind ()) {
00106 case CORBA::tk_objref: Add_IR_Comment (xml, "reference", tcp); break;
00107 case CORBA::tk_struct: Add_IR_Comment (xml, "struct", tcp); break;
00108 case CORBA::tk_union: Add_IR_Comment (xml, "union", tcp); break;
00109 case CORBA::tk_except: Add_IR_Comment (xml, "except", tcp); break;
00110 case CORBA::tk_enum: Add_IR_Comment (xml, "enum", tcp); break;
00111 case CORBA::tk_alias: Add_IR_Comment (xml, "alias", tcp); break;
00112 };
00113 switch (tcp->kind ()) {
00114 case CORBA::tk_null:
00115 xml += "<!-- WARNING: tk_null found in parameters! -->";
00116 break;
00117 case CORBA::tk_void:
00118 xml += "<!-- void -->";
00119 break;
00120 case CORBA::tk_short:
00121 xml += "<!-- short -->";
00122 break;
00123 case CORBA::tk_long:
00124 xml += "<!-- long -->";
00125 break;
00126 case CORBA::tk_ushort:
00127 xml += "<!-- unsigned short -->";
00128 break;
00129 case CORBA::tk_ulong:
00130 xml += "<!-- unsigned long -->";
00131 break;
00132 case CORBA::tk_float:
00133 xml += "<!-- float -->";
00134 break;
00135 case CORBA::tk_double:
00136 xml += "<!-- double -->";
00137 break;
00138 case CORBA::tk_boolean:
00139 xml += "<!-- boolean -->";
00140 break;
00141 case CORBA::tk_char:
00142 xml += "<!-- char -->";
00143 break;
00144 case CORBA::tk_octet:
00145 xml += "<!-- octet -->";
00146 break;
00147 case CORBA::tk_any:
00148 xml += "<!-- WARNING: any found in parameters. Conversion definition is required! -->";
00149 break;
00150 case CORBA::tk_TypeCode:
00151 xml += "<!-- CORBA::TypeCode -->";
00152 break;
00153 case CORBA::tk_Principal:
00154 xml += "<!-- CORBA::Principal -->";
00155 break;
00156 case CORBA::tk_objref:
00157
00158 break;
00159 case CORBA::tk_struct:
00160 {
00161 if (!tlist->Exists (tcp)) {
00162 (void) new TypeCodeElm (tlist, tcp);
00163 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00164 CORBA::String_var mem (tcp->member_name (i));
00165 xml += "<m:";
00166 xml += mem;
00167 xml += ">";
00168 CORBA::TypeCode_var tc (tcp->member_type (i));
00169 RecurseFields (xml, tlist, tc);
00170 xml += "</m:";
00171 xml += mem;
00172 xml += ">";
00173 }
00174 }
00175 }
00176 break;
00177 case CORBA::tk_union:
00178 {
00179 if (!tlist->Exists (tcp)) {
00180 (void) new TypeCodeElm (tlist, tcp);
00181 xml += "<m:discriminator>";
00182 CORBA::TypeCode_var dt (tcp->discriminator_type ());
00183 RecurseFields (xml, tlist, dt);
00184 xml += "</m:discriminator>";
00185 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00186 CORBA::String_var mem (tcp->member_name (i));
00187 xml += "<m:";
00188 xml += mem;
00189 xml += ">";
00190 CORBA::TypeCode_var tc (tcp->member_type (i));
00191 RecurseFields (xml, tlist, tc);
00192 xml += "</m:";
00193 xml += mem;
00194 xml += ">";
00195 }
00196 }
00197 }
00198 break;
00199 case CORBA::tk_enum:
00200 {
00201 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00202 CORBA::String_var mem (tcp->member_name (i));
00203 xml += "<!-- ";
00204 xml += mem;
00205 xml += " -->";
00206 }
00207 }
00208 break;
00209 case CORBA::tk_string:
00210 xml += "<!-- string -->";
00211 break;
00212 case CORBA::tk_sequence:
00213 {
00214 CString rem;
00215 if (tcp->length () != 0) {
00216 rem.Format ("<!-- sequence (max=%d) -->", tcp->length ());
00217 } else {
00218 rem = "<!-- sequence (unbound) -->";
00219 }
00220 xml += rem;
00221 CORBA::TypeCode_var tc (tcp->content_type ());
00222 RecurseFields (xml, tlist, tc);
00223 }
00224 break;
00225 case CORBA::tk_array:
00226 {
00227 CString rem;
00228 rem.Format ("<!-- array (%d) -->", tcp->length ());
00229 xml += rem;
00230 CORBA::TypeCode_var tc (tcp->content_type ());
00231 RecurseFields (xml, tlist, tc);
00232 }
00233 break;
00234 case CORBA::tk_alias:
00235 {
00236 CORBA::TypeCode_var tc (tcp->content_type ());
00237 RecurseFields (xml, tlist, tc);
00238 }
00239 break;
00240 case CORBA::tk_except:
00241 {
00242 if (!tlist->Exists (tcp)) {
00243 (void) new TypeCodeElm (tlist, tcp);
00244 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00245 CORBA::String_var mem (tcp->member_name (i));
00246 xml += "<m:";
00247 xml += mem;
00248 xml += ">";
00249 CORBA::TypeCode_var tc (tcp->member_type (i));
00250 RecurseFields (xml, tlist, tc);
00251 xml += "</m:";
00252 xml += mem;
00253 xml += ">";
00254 }
00255 }
00256 }
00257 break;
00258 case CORBA::tk_longlong:
00259 xml += "<!-- long long -->";
00260 break;
00261 case CORBA::tk_ulonglong:
00262 xml += "<!-- unsigned long long -->";
00263 break;
00264 case CORBA::tk_longdouble:
00265 xml += "<!-- long double -->";
00266 break;
00267 case CORBA::tk_wchar:
00268 xml += "<!-- wchar -->";
00269 break;
00270 case CORBA::tk_wstring:
00271 xml += "<!-- wstring -->";
00272 break;
00273 case CORBA::tk_fixed:
00274 {
00275 CString rem;
00276 rem.Format ("<!-- fixed (digits=%u, scale=%u) -->", tcp->fixed_digits (), tcp->fixed_scale ());
00277 xml += rem;
00278 }
00279 break;
00280 default:
00281 xml += "<!-- ERROR: Unknown TypeCode encountered in parameter! -->";
00282 break;
00283 }
00284 }
00285
00286 void IRPlus::InsertIRFieldRecord (SCMethParam *pParm, DOSnapshot *pTab, const CString &path, const char *fieldName)
00287 {
00288 DOQuery Q (pCon);
00289 CString pf, q;
00290 pf = path;
00291 pf += fieldName;
00292 q.Format ("select parfield,convid,convinfo from irplus where methpath='%s' and param='%s' and parfield='%s'",
00293 (const char *) pParm->GetInterfaceMethod ()->m_mthPath, (const char *) pParm->m_prmName,
00294 (const char *) (pf));
00295 Q.Query (q);
00296 if (Q.GetNumRows ()) {
00297 pTab->AddNew ();
00298 pTab->Let ("methuid", pParm->getMthId ());
00299 pTab->Let ("paramnum", pParm->m_prmId);
00300 pTab->Let ("parfield", pf);
00301 pTab->Let ("convid", atoi (Q.FindQueryField ("convid")->GetValue ()));
00302 pTab->Let ("convinfo", Q.FindQueryField ("convinfo")->GetValue ());
00303 pTab->CommitAdd (false, false);
00304 } else {
00305 pTab->AddNew ();
00306 pTab->Let ("methuid", pParm->getMthId ());
00307 pTab->Let ("paramnum", pParm->m_prmId);
00308 pTab->Let ("parfield", pf);
00309 pTab->Let ("convid", 0);
00310 pTab->Let ("convinfo", "");
00311 pTab->CommitAdd (false, false);
00312 }
00313 }
00314
00322 void IRPlus::RecurseFields (SCMethParam *pParm,
00323 DOSnapshot *pTab,
00324 const CString &path,
00325 TypeCodeList *tlist,
00326 CORBA::TypeCode_ptr tcp,
00327 const char *hint)
00328 {
00329 switch (tcp->kind ()) {
00330 case CORBA::tk_null:
00331 case CORBA::tk_void:
00332 case CORBA::tk_short:
00333 case CORBA::tk_long:
00334 case CORBA::tk_ushort:
00335 case CORBA::tk_ulong:
00336 case CORBA::tk_float:
00337 case CORBA::tk_double:
00338 case CORBA::tk_boolean:
00339 case CORBA::tk_char:
00340 case CORBA::tk_octet:
00341 case CORBA::tk_any:
00342 case CORBA::tk_TypeCode:
00343 case CORBA::tk_Principal:
00344 case CORBA::tk_objref:
00345 case CORBA::tk_string:
00346 case CORBA::tk_longlong:
00347 case CORBA::tk_ulonglong:
00348 case CORBA::tk_longdouble:
00349 case CORBA::tk_wchar:
00350 case CORBA::tk_wstring:
00351 case CORBA::tk_fixed:
00352 case CORBA::tk_enum:
00353 InsertIRFieldRecord (pParm, pTab, path, ".");
00354 break;
00355 case CORBA::tk_alias:
00356 {
00357 CORBA::String_var nam (tcp->name ());
00358 CORBA::TypeCode_var tc (tcp->content_type ());
00359 RecurseFields (pParm, pTab, path, tlist, tc, nam);
00360 }
00361 break;
00362 case CORBA::tk_sequence:
00363 case CORBA::tk_array:
00364 {
00365 CORBA::TypeCode_var tc (tcp->content_type ());
00366 CString elmNam = ".";
00367 switch (tc->kind ()) {
00368 case CORBA::tk_objref:
00369 case CORBA::tk_struct:
00370 case CORBA::tk_union:
00371 case CORBA::tk_except:
00372 case CORBA::tk_enum:
00373 case CORBA::tk_alias:
00374 {
00375 CORBA::String_var nam (tc->name ());
00376 elmNam += (char *) nam;
00377 }
00378 break;
00379 default:
00380 {
00381 if (hint != NULL) {
00382 elmNam += hint;
00383 } else {
00384 if (tcp->kind () == CORBA::tk_sequence) {
00385 elmNam += "seqElm";
00386 } else {
00387 elmNam += "arrElm";
00388 }
00389 }
00390 }
00391 break;
00392 };
00393 RecurseFields (pParm, pTab, path + elmNam, tlist, tc);
00394 }
00395 break;
00396 case CORBA::tk_struct:
00397 case CORBA::tk_except:
00398 {
00399 if (!tlist->Exists (tcp)) {
00400 (void) new TypeCodeElm (tlist, tcp);
00401 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00402 CORBA::String_var mem (tcp->member_name (i));
00403 CORBA::TypeCode_var tc (tcp->member_type (i));
00404 CString nPath = path + ".";
00405 nPath += mem;
00406 RecurseFields (pParm, pTab, nPath, tlist, tc);
00407 }
00408 } else {
00409 InsertIRFieldRecord (pParm, pTab, path, ":");
00410 }
00411 }
00412 break;
00413 case CORBA::tk_union:
00414 {
00415 if (!tlist->Exists (tcp)) {
00416 (void) new TypeCodeElm (tlist, tcp);
00417 CORBA::TypeCode_var dt (tcp->discriminator_type ());
00418 RecurseFields (pParm, pTab, path + ".discriminator", tlist, dt);
00419 for (unsigned int i = 0; i < tcp->member_count (); i ++) {
00420 CORBA::String_var mem (tcp->member_name (i));
00421 CORBA::TypeCode_var tc (tcp->member_type (i));
00422 CString nPath;
00423 nPath.Format ("%s.%u.%s", (const char *) path, i, (char *) mem);
00424 RecurseFields (pParm, pTab, nPath, tlist, tc);
00425 }
00426 } else {
00427 InsertIRFieldRecord (pParm, pTab, path, ":");
00428 }
00429 }
00430 break;
00431 default:
00432 generalLog->crit ("<!-- ERROR: Unknown TypeCode encountered in parameter! -->\n");
00433 break;
00434 }
00435 }
00436
00443 void showTC (CString &xml, CORBA::TypeCode_ptr tc)
00444 {
00445 TypeCodeList tlist;
00446 RecurseFields (xml, &tlist, tc);
00447 }
00448
00457 bool GetSOAP (CString &xml_in, CString &xml_out, IRPLUS_H hdl, const char *interfaceMethod)
00458 {
00459 xml_in.Empty ();
00460 xml_out.Empty ();
00461 IRPlus *pirp = (IRPlus *) hdl;
00462 JTCSynchronized synchronized (pirp->monitor);
00463 CString key = "/";
00464 key += interfaceMethod;
00465 int pSign;
00466 while ((pSign = key.Find ('#')) >= 0) {
00467 key.SetAt (pSign, '/');
00468 }
00469 SCInterfaceMethod *pMeth = pirp->IRC.FindInterfaceMethod (key);
00470 if (!pMeth) return false;
00471 const char *methName = strchr (interfaceMethod, '#') + 1;
00472 xml_in = "<m:";
00473 xml_in += methName;
00474 xml_in += " xmlns:m=\"corbaOperation\">";
00475 xml_out += "<";
00476 xml_out += methName;
00477 xml_out += "Response xmlns:m=\"corbaOperation\">";
00478 SCInterfaceMethod::MethParamIterator iter (pMeth);
00479 while (++iter) {
00480 switch (iter->m_prmKind) {
00481 case ioeIn:
00482 xml_in += "<m:";
00483 xml_in += iter->m_prmName;
00484 xml_in += ">";
00485 showTC (xml_in, iter->m_tc);
00486 xml_in += "</m:";
00487 xml_in += iter->m_prmName;
00488 xml_in += ">";
00489 break;
00490 case ioeOut:
00491 xml_out += "<m:";
00492 xml_out += iter->m_prmName;
00493 xml_out += ">";
00494 showTC (xml_out, iter->m_tc);
00495 xml_out += "</m:";
00496 xml_out += iter->m_prmName;
00497 xml_out += ">";
00498 break;
00499 case ioeInOut:
00500 xml_in += "<m:";
00501 xml_in += iter->m_prmName;
00502 xml_in += ">";
00503 showTC (xml_in, iter->m_tc);
00504 xml_in += "</m:";
00505 xml_in += iter->m_prmName;
00506 xml_in += ">";
00507 xml_out += "<m:";
00508 xml_out += iter->m_prmName;
00509 xml_out += ">";
00510 showTC (xml_out, iter->m_tc);
00511 xml_out += "</m:";
00512 xml_out += iter->m_prmName;
00513 xml_out += ">";
00514 break;
00515 }
00516 }
00517 xml_in += "</m:";
00518 xml_in += methName;
00519 xml_in += ">";
00520 xml_out += "</m:";
00521 xml_out += methName;
00522 xml_out += ">";
00523 return true;
00524 }
00525
00526 SCInterfaceMethod *IRPlus::newMeth (const char *Path)
00527 {
00528 DOQuery Q (pCon);
00529 CString q;
00530 q = "select * from irplus where methpath='";
00531 q += Path;
00532 q += "' and isnull(param)";
00533 Q.Query (q);
00534 int irplusid = 0;
00535 SCInterfaceMethod *pMeth = new SCInterfaceMethod (&IRC, ++midNum, Path);
00536 if (Q.GetNumRows ()) {
00537 irplusid = atoi (Q.FindQueryField ("irplusid")->GetValue ());
00538 pMeth->m_convId = atoi (Q.FindQueryField ("convid")->GetValue ());
00539 pMeth->m_convInfo = Q.FindQueryField ("convInfo")->GetValue ();
00540 }
00541 q.Format ("insert into irmeth values (%d, '%s', %d)",
00542 midNum, Path, irplusid);
00543 Q.Query (q);
00544 return pMeth;
00545 }
00546
00547 SCMethParam *IRPlus::newParam (SCInterfaceMethod *pMeth, const char *Param, InOutExcept kind, CORBA::TypeCode_ptr ptc)
00548 {
00549 SCMethParam *pParm = new SCMethParam (pMeth, ++pidNum, Param, kind, ptc, orb);
00550 DOQuery Q (pCon);
00551 CString q;
00552 q.Format ("select irplus.irplusid,irplus.convid,irplus.convinfo from irplus,irmeth where \
00553 (irmeth.methuid=%d) and (irplus.methpath=irmeth.methpath) \
00554 and (irplus.param='%s')", pMeth->m_mthId, Param);
00555 Q.Query (q);
00556 int irplusid = 0;
00557 if (Q.GetNumRows ()) {
00558 irplusid = atoi (Q.FindQueryField ("irplusid")->GetValue ());
00559 pParm->m_convId = atoi (Q.FindQueryField ("convid")->GetValue ());
00560 pParm->m_convInfo = Q.FindQueryField ("convInfo")->GetValue ();
00561 }
00562 q.Format ("insert into irparm values (%d, %d, '%s', %d)",
00563 pMeth->m_mthId, pidNum, Param, irplusid);
00564 Q.Query (q);
00565 return pParm;
00566 }
00567
00568 void IRPlus::FetchParamFields (DOSnapshot *pTab, SCMethParam *pParm)
00569 {
00570 TypeCodeList tlist;
00571 RecurseFields (pParm, pTab, "", &tlist, pParm->m_tc);
00572 }
00573
00574 void IRPlus::RecurseIR (CORBA::Repository_ptr pIR,
00575 DynamicAny::DynAnyFactory_ptr dynFact,
00576 CORBA::Contained_ptr ptr,
00577 const char *path)
00578 {
00579 switch (ptr->def_kind ()) {
00580 case CORBA::dk_Module:
00581 {
00582 CORBA::ModuleDef_var irObj = CORBA::ModuleDef::_narrow (ptr);
00583 CORBA::String_var obj_name = irObj->name ();
00584 CORBA::String_var obj_id = irObj->id ();
00585 try {
00586 CORBA::ContainedSeq *ifrContents = irObj->contents (CORBA::dk_all, 0);
00587 unsigned int i;
00588 for (i = 0; i < ifrContents->length (); i ++) {
00589 CORBA::Contained_var cnt ((*ifrContents) [i]);
00590 CString Path = path;
00591 Path += (char *) obj_name;
00592 Path += '/';
00593 RecurseIR (pIR, dynFact, cnt, Path);
00594 }
00595 delete ifrContents;
00596 }
00597 catch (const CORBA::Exception &) {
00598 generalLog->crit ("Error: Failed to iterate Module\n");
00599 }
00600 }
00601 break;
00602 case CORBA::dk_Interface:
00603 {
00604 CORBA::InterfaceDef_var irObj = CORBA::InterfaceDef::_narrow (ptr);
00605 CORBA::String_var obj_name = irObj->name ();
00606 try {
00607 CORBA::ContainedSeq *ifrContents = irObj->contents (CORBA::dk_all, 0);
00608 unsigned int i;
00609 for (i = 0; i < ifrContents->length (); i ++) {
00610 CORBA::Contained_var cnt ((*ifrContents) [i]);
00611 CString Path = path;
00612 Path += (char *) obj_name;
00613 Path += '/';
00614 RecurseIR (pIR, dynFact, cnt, Path);
00615 }
00616 delete ifrContents;
00617 }
00618 catch (const CORBA::Exception &e) {
00619 generalLog->crit ("Error: Failed to iterate Interface %08X\n", (unsigned long) &e);
00620 }
00621 }
00622 break;
00623 case CORBA::dk_Operation:
00624 {
00625 CORBA::OperationDef_var irObj = CORBA::OperationDef::_narrow (ptr);
00626 CORBA::String_var obj_name = irObj->name ();
00627 CORBA::String_var obj_id = irObj->id ();
00628 CString Path = path;
00629 Path += (char *) obj_name;
00630 SCInterfaceMethod *pMeth = newMeth (Path);
00631 CORBA::TypeCode_var _rtc = irObj->result ();
00632 (void) newParam (pMeth, "return", ioeOut, _rtc);
00633 try {
00634 unsigned int i;
00635 {
00636 CORBA::ParDescriptionSeq_var pars = irObj->params ();
00637 for (i = 0; i < pars->length (); i ++) {
00638 InOutExcept ioe;
00639 switch ((*pars) [i].mode) {
00640 case CORBA::PARAM_IN: ioe = ioeIn; break;
00641 case CORBA::PARAM_OUT: ioe = ioeOut; break;
00642 case CORBA::PARAM_INOUT: ioe = ioeInOut; break;
00643 }
00644 (void) newParam (pMeth, (*pars) [i].name, ioe, (*pars) [i].type);
00645 }
00646 }
00647 {
00648 CORBA::ExceptionDefSeq_var excs = irObj->exceptions ();
00649 for (i = 0; i < excs->length (); i ++) {
00650 CORBA::TypeCode_var _tc_ = ((*excs) [i])->type ();
00651 CORBA::String_var exc_name = ((*excs) [i])->name ();
00652 (void) newParam (pMeth, exc_name, ioeException, _tc_);
00653 }
00654 }
00655 }
00656 catch (const CORBA::Exception &) {
00657 generalLog->crit ("Error: Failed to iterate Operation\n");
00658 }
00659 }
00660 break;
00661 case CORBA::dk_Attribute:
00662 {
00663 CORBA::AttributeDef_var irObj = CORBA::AttributeDef::_narrow (ptr);
00664 CORBA::String_var obj_name = irObj->name ();
00665 CORBA::String_var obj_id = irObj->id ();
00666 CString Path = path;
00667 Path += "_get_";
00668 Path += (char *) obj_name;
00669 SCInterfaceMethod *pMeth = newMeth (Path);
00670 CORBA::TypeCode_var _tc_ = irObj->type ();
00671 (void) newParam (pMeth, "return", ioeOut, _tc_);
00672 if (irObj->mode () != CORBA::ATTR_READONLY) {
00673 Path = path;
00674 Path += "_set_";
00675 Path += (char *) obj_name;
00676 pMeth = newMeth (Path);
00677 (void) newParam (pMeth, "value", ioeIn, _tc_);
00678 }
00679 }
00680 break;
00681 #if 0
00682 case CORBA::dk_Constant:
00683 {
00684 CORBA::ConstantDef_var irObj = CORBA::ConstantDef::_narrow (ptr);
00685 CORBA::String_var obj_name = irObj->name ();
00686 CORBA::String_var obj_id = irObj->id ();
00687 CORBA::TypeCode_var _tc_ = irObj->type ();
00688 DcReferenceType *pType = pRepository->FindOrAddTypeCode (_tc_);
00689 CORBA::Any_var _any_ = irObj->value ();
00690 (void) new DcConstant (this, (char *) obj_name, (char *) obj_id, pType, _any_);
00691 }
00692 break;
00693 #endif
00694 default:
00695 break;
00696 }
00697 }
00698
00699 void IRPlus::createTables ()
00700 {
00701 DOQuery Q (pCon);
00702 CString q;
00703 Q.Query ("drop table if exists irparm");
00704 Q.Query ("drop table if exists irmeth");
00705 q = "create table ";
00706 q += "irmeth (";
00707 q += "methuid int not null auto_increment primary key, ";
00708 q += "methpath varchar(255) not null, ";
00709 q += "irplusid int)";
00710 Q.Query (q);
00711 q = "create table ";
00712 q += "irparm (";
00713 q += "methuid int not null, ";
00714 q += "paramnum int not null auto_increment, ";
00715 q += "param varchar(80) not null, ";
00716 q += "irplusid int, ";
00717 q += "primary key (methuid,paramnum))";
00718 Q.Query (q);
00719 q = "create table if not exists ";
00720 q += "irplus (";
00721 q += "irplusid int not null auto_increment primary key, ";
00722 q += "methpath varchar(255) not null, ";
00723 q += "param varchar(80), ";
00724 q += "convid int, ";
00725 q += "convinfo varchar (255))";
00726 Q.Query (q);
00727 }
00728
00729 int IRPlus::Init ()
00730 {
00731 createTables ();
00732 try {
00733 CORBA::Object_var obj;
00734 DynamicAny::DynAnyFactory_var Factory;
00735 CORBA::Repository_var IR;
00736 CosNaming::NamingContext_var nmc;
00737 CORBA::Object_var ir;
00738 CosNaming::Name name;
00739 try {
00740 obj = orb->resolve_initial_references ("DynAnyFactory");
00741 Factory = DynamicAny::DynAnyFactory::_narrow (obj);
00742 }
00743 catch (...) {
00744 generalLog->crit ("No DynAnyFactory\n");
00745 throw (0);
00746 }
00747 try {
00748 obj = orb->resolve_initial_references ("NameService");
00749 nmc = CosNaming::NamingContext::_narrow (obj);
00750 assert (!CORBA::is_nil (nmc));
00751 }
00752 catch (...) {
00753 generalLog->crit ("No NameService\n");
00754 throw (0);
00755 }
00756 name.length (1);
00757 name [0].id = CORBA::string_dup ("InterfaceRepository");
00758 ir = nmc->resolve (name);
00759 if (CORBA::is_nil (ir)) {
00760 generalLog->crit ("Nil InterfaceRepository reference\n");
00761 } else {
00762 IR = CORBA::Repository::_narrow (ir);
00763 }
00764 try {
00765 CORBA::ContainedSeq *ifrContents = IR->contents (CORBA::dk_all, 0);
00766 unsigned int i;
00767 for (i = 0; i < ifrContents->length (); i ++) {
00768 try {
00769 CORBA::Contained_var cnt = (*ifrContents) [i];
00770 CORBA::String_var cnt_name = cnt->name ();
00771 generalLog->info ("IR container: %s\n", (char *) cnt_name);
00772 RecurseIR (IR, Factory, cnt, "/");
00773 }
00774 catch (const CORBA::Exception &) {
00775 generalLog->crit ("Error: Failed to process InterfaceRepository entry\n");
00776 }
00777 }
00778 delete ifrContents;
00779 }
00780 catch (const CORBA::Exception &) {
00781 generalLog->crit ("Error: Failed to iterate InterfaceRepository\n");
00782 }
00783 }
00784 catch (...) {
00785 generalLog->crit ("Oops!\n");
00786 }
00787 return 0;
00788 }
00789
