00001
00018
00019
00020
00021 #include "OSDipInterface.h"
00022 #include "UtilMacrosDecomp.h"
00023
00024
00025 void OS_DipInterface::readOSiL(string & fileName) {
00026
00027 FileUtil *fileUtil = NULL;
00028 fileUtil = new FileUtil();
00029
00030 try {
00031
00032 std::string osil;
00033 osil = fileUtil->getFileAsString(fileName.c_str());
00034 m_osilreader = new OSiLReader();
00035 m_osinstance = m_osilreader->readOSiL(osil);
00036
00037 bool columnMajor = false;
00038 double maxGap = 0;
00039
00040 m_coinpm
00041 = new CoinPackedMatrix(
00042 columnMajor,
00043 columnMajor ? m_osinstance->getConstraintNumber()
00044 : m_osinstance->getVariableNumber(),
00045 columnMajor ? m_osinstance->getVariableNumber()
00046 : m_osinstance->getConstraintNumber(),
00047 m_osinstance->getLinearConstraintCoefficientNumber(),
00048 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->values
00049 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->values,
00050 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes
00051 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->indexes,
00052 columnMajor ? m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts
00053 : m_osinstance->getLinearConstraintCoefficientsInRowMajor()->starts,
00054 0, 0, maxGap);
00055
00056 delete fileUtil;
00057 fileUtil = NULL;
00058
00059
00060
00061
00062
00063 } catch (const ErrorClass& eclass) {
00064 std::cout << "PROBLEM READING OSiL File" << std::endl;
00065 delete fileUtil;
00066 std::cout << eclass.errormsg << std::endl;
00067 fileUtil = NULL;
00068 throw ErrorClass(eclass.errormsg);
00069
00070 }
00071
00072 }
00073
00074
00075
00076 void OS_DipInterface::readOSoL(string & fileName) {
00077
00078 FileUtil *fileUtil = NULL;
00079 fileUtil = new FileUtil();
00080 try {
00081
00082 std::string osol;
00083 osol = fileUtil->getFileAsString(fileName.c_str());
00084 m_osolreader = new OSoLReader();
00085 m_osoption = m_osolreader->readOSoL(osol);
00086
00087 delete fileUtil;
00088 fileUtil = NULL;
00089
00090
00091
00092
00093
00094 } catch (const ErrorClass& eclass) {
00095 std::cout << "Problem reading OSoL File" << std::endl;
00096 delete fileUtil;
00097 std::cout << eclass.errormsg << std::endl;
00098 fileUtil = NULL;
00099 throw ErrorClass(eclass.errormsg);
00100
00101 }
00102
00103 }
00104
00105 CoinPackedMatrix * OS_DipInterface::getCoinPackedMatrix() {
00106
00107 return m_coinpm;
00108 }
00109
00110 CoinPackedVector * OS_DipInterface::getRow(int i) {
00111
00112 m_row = new CoinPackedVector();
00113
00114 int k;
00115
00116 SparseMatrix* sm;
00117
00118 sm = m_osinstance->getLinearConstraintCoefficientsInRowMajor();
00119
00120 for (k = sm->starts[i]; k < sm->starts[i + 1]; k++) {
00121
00122 m_row->insert(sm->indexes[k], sm->values[k]);
00123
00124 }
00125
00126 return m_row;
00127 }
00128
00129 const char* OS_DipInterface::getIntegerColumns() {
00130
00131 int numVars = getVariableNumber();
00132 m_integerVars = new char[numVars];
00133 int i;
00134
00135 for (i = 0; i < numVars; i++) {
00136
00137 if (m_osinstance->getVariableTypes()[i] == 'B'
00138 || m_osinstance->getVariableTypes()[i] == 'I')
00139 m_integerVars[i] = '1';
00140 else
00141 m_integerVars[i] = '0';
00142
00143 }
00144 return m_integerVars;
00145
00146 }
00147
00148
00149 double OS_DipInterface::getObjectiveOffset() {
00150
00151 double offset = 0;
00152
00153
00154 if (getObjectiveConstants() != NULL) {
00155 offset = getObjectiveConstants()[0];
00156 }
00157
00158 return offset;
00159 }
00160
00161
00162 std::vector<std::string> OS_DipInterface::getBlockFactories() {
00163
00164
00165
00166 if (m_blockFactoriesProcessed == true)
00167 return m_blockFactories;
00168
00169 try {
00170 if (m_osoption == NULL)
00171 throw ErrorClass("we have a null osoption");
00172
00173 std::vector<OtherVariableOption*> otherVariableOptions;
00174 std::vector<OtherVariableOption*>::iterator vit;
00175
00176 if (m_osoption != NULL && m_osoption->getNumberOfOtherVariableOptions()
00177 > 0) {
00178
00179 otherVariableOptions = m_osoption->getOtherVariableOptions("Dip");
00180
00181 for (vit = otherVariableOptions.begin(); vit
00182 != otherVariableOptions.end(); vit++) {
00183
00184
00185 if ((*vit)->name.compare("variableBlockSet") == 0) {
00186
00187 if ((*vit)->value.size() > 0) {
00188
00189 m_blockFactories.push_back((*vit)->value);
00190
00191 } else {
00192
00193 m_blockFactories.push_back("");
00194 }
00195
00196 }
00197
00198 }
00199 }
00200
00201 }
00202
00203 catch (const ErrorClass& eclass) {
00204
00205 std::cout << eclass.errormsg << std::endl;
00206 throw ErrorClass(eclass.errormsg);
00207
00208 }
00209 m_blockFactoriesProcessed = true;
00210 return m_blockFactories;
00211 }
00212
00213 std::vector<std::set<int> > OS_DipInterface::getBlockVarIndexes() {
00214
00215
00216 std::set<int> varSet;
00217 if (m_blockVariableIndexesProcessed == true)
00218 return m_blockVariableIndexes;
00219
00220 try {
00221 if (m_osoption == NULL)
00222 throw ErrorClass("we have a null osoption");
00223
00224 int numVar;
00225 int i;
00226 std::vector<OtherVariableOption*> otherVariableOptions;
00227 std::vector<OtherVariableOption*>::iterator vit;
00228
00229 if (m_osoption != NULL && m_osoption->getNumberOfOtherVariableOptions()
00230 > 0) {
00231
00232 otherVariableOptions = m_osoption->getOtherVariableOptions("Dip");
00233
00234 for (vit = otherVariableOptions.begin(); vit
00235 != otherVariableOptions.end(); vit++) {
00236
00237
00238 if ((*vit)->name.compare("variableBlockSet") == 0) {
00239
00240
00241
00242 varSet.clear();
00243
00244 numVar = (*vit)->numberOfVar;
00245
00246 for (i = 0; i < numVar; i++) {
00247
00248 if ((*vit)->var[i]->idx
00249 >= m_osinstance->getVariableNumber())
00250 throw ErrorClass(
00251 "found an invalid varaible index in OSoL file");
00252
00253 varSet.insert((*vit)->var[i]->idx);
00254
00255 }
00256
00257 m_blockVariableIndexes.push_back(varSet);
00258 }
00259
00260
00261 }
00262 }
00263
00264
00265 if (m_blockVariableIndexes.size() <= 0)
00266 throw ErrorClass("someting wrong -- no variables in the blocks");
00267
00268 }
00269
00270 catch (const ErrorClass& eclass) {
00271
00272 std::cout << eclass.errormsg << std::endl;
00273 throw ErrorClass(eclass.errormsg);
00274
00275 }
00276 m_blockVariableIndexesProcessed = true;
00277 return m_blockVariableIndexes;
00278 }
00279
00280
00281 std::vector<std::map<int, int> > OS_DipInterface::getBlockConstraintIndexes() {
00282
00283 if (m_blockConstraintIndexesProcessed == true)
00284 return m_blockConstraintIndexes;
00285
00286 std::map<int, int> conMap;
00287 std::set<int> varSet;
00288 std::set<int> coreConstraintIndexes;
00289 std::vector<std::set<int> > blockVariableIndexes;
00290
00291 int *starts = NULL;
00292 int *indexes = NULL;
00293 int kount;
00294
00295 try {
00296
00297
00298 blockVariableIndexes = getBlockVarIndexes();
00299
00300 coreConstraintIndexes = getCoreConstraintIndexes();
00301
00302 if (blockVariableIndexes.size() <= 0)
00303 throw ErrorClass("someting wrong -- no variables in the blocks");
00304
00305 std::vector<std::set<int> >::iterator vit;
00306 std::set<int>::iterator sit;
00307 int i;
00308
00309 for (vit = blockVariableIndexes.begin(); vit
00310 != blockVariableIndexes.end(); vit++) {
00311
00312 varSet.clear();
00313 conMap.clear();
00314
00315 varSet = *vit;
00316
00317
00318
00319 kount = 0;
00320 for (sit = varSet.begin(); sit != varSet.end(); sit++) {
00321
00322 starts
00323 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts;
00324 indexes
00325 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes;
00326
00327 for (i = starts[*sit]; i < starts[*sit + 1]; i++) {
00328
00329
00330
00331 if (coreConstraintIndexes.find(indexes[i])
00332 == coreConstraintIndexes.end() &&
00333 (conMap.find(indexes[i] ) == conMap.end() )
00334 ) {
00335
00336
00337 conMap.insert(make_pair(indexes[i], kount));
00338 kount++;
00339 }
00340 }
00341 }
00342
00343 m_blockConstraintIndexes.push_back(conMap);
00344
00345 }
00346
00347
00348 }
00349
00350 catch (const ErrorClass& eclass) {
00351
00352 std::cout << eclass.errormsg << std::endl;
00353 throw ErrorClass(eclass.errormsg);
00354
00355 }
00356 m_blockConstraintIndexesProcessed = true;
00357 return m_blockConstraintIndexes;
00358 }
00359
00360
00361 std::vector<OSInstance*> OS_DipInterface::getBlockOSInstances() {
00362
00363 if (m_blockOSInstancesProcessed == true)
00364 return m_blockOSInstances;
00365
00366 std::map<int, int> conMap;
00367 std::set<int> varSet;
00368 std::vector<std::map<int, int> > blockConstraintIndexes;
00369 std::set<int> coreConstraintIndexes;
00370 std::vector<std::set<int> > blockVariableIndexes;
00371
00372 int *starts = NULL;
00373 int *indexes = NULL;
00374 double *values = NULL;
00375
00376 OSInstance *osinstance;
00377 std::vector<std::set<int> >::iterator vit;
00378 std::set<int>::iterator sit;
00379 std::map<int, int>::iterator mit;
00380 int i;
00381 int kount;
00382
00383 int whichBlock;
00384 int numNonz;
00385 int k1, k2;
00386
00387
00388 int numberVar;
00389 std::string* varNames = NULL;
00390 char* varTypes = NULL;
00391 double* varLowerBounds = NULL;
00392 double* varUpperBounds = NULL;
00393
00394
00395 int numberCon;
00396 std::string* conNames = NULL;
00397 double* conLowerBounds = NULL;
00398 double* conUpperBounds = NULL;
00399 double* conConstants = NULL;
00400
00401 int idx;
00402
00403 try {
00404
00405
00406 blockVariableIndexes = getBlockVarIndexes();
00407
00408
00409 coreConstraintIndexes = getCoreConstraintIndexes();
00410
00411
00412 blockConstraintIndexes = getBlockConstraintIndexes();
00413
00414 if (blockVariableIndexes.size() <= 0)
00415 throw ErrorClass(
00416 "someting wrong in getBlockOSInstances() -- no variables in the blocks");
00417
00418
00419
00420
00421 whichBlock = 0;
00422 for (vit = blockVariableIndexes.begin(); vit
00423 != blockVariableIndexes.end(); vit++) {
00424
00425 varSet.clear();
00426 conMap.clear();
00427 varSet = *vit;
00428
00429 osinstance = new OSInstance();
00430
00431 numberVar = varSet.size();
00432 varTypes = new char[numberVar];
00433 varNames = new string[numberVar];
00434 varLowerBounds = new double[numberVar];
00435 varUpperBounds = new double[numberVar];
00436
00437
00438
00439
00440 kount = 0;
00441
00442 osinstance->setVariableNumber(numberVar);
00443
00444 SparseVector *objcoeff;
00445 objcoeff = new SparseVector(numberVar);
00446
00447
00448
00449 numNonz = 0;
00450
00451 for (sit = varSet.begin(); sit != varSet.end(); sit++) {
00452
00453 varTypes[kount] = m_osinstance->getVariableTypes()[*sit];
00454 varLowerBounds[kount]
00455 = m_osinstance->getVariableLowerBounds()[*sit];
00456 varUpperBounds[kount]
00457 = m_osinstance->getVariableUpperBounds()[*sit];
00458
00459 varNames[kount] = m_osinstance->getVariableNames()[*sit];
00460
00461 objcoeff->indexes[kount] = kount;
00462
00463 objcoeff->values[kount] = m_osinstance->getDenseObjectiveCoefficients()[0][ *sit];
00464 numNonz
00465 += m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit + 1]
00466 - m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit];
00467
00468 kount++;
00469
00470 }
00471
00472 osinstance->setVariables(numberVar, varNames, varLowerBounds,
00473 varUpperBounds, varTypes);
00474
00475
00476 osinstance->setObjectiveNumber(1);
00477
00478 osinstance->addObjective(-1, "objfunction",
00479 m_osinstance->getObjectiveMaxOrMins()[0], 0.0, 1.0,
00480 objcoeff);
00481
00482 conMap = blockConstraintIndexes[whichBlock];
00483 numberCon = conMap.size();
00484
00485 if (numberCon > 0) {
00486
00487 starts = new int[numberVar + 1];
00488 indexes = new int[numNonz];
00489 values = new double[numNonz];
00490 kount = 0;
00491 starts[kount] = 0;
00492
00493 numNonz = 0;
00494 for (sit = varSet.begin(); sit != varSet.end(); sit++) {
00495
00496 k2
00497 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit
00498 + 1];
00499 k1
00500 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->starts[*sit];
00501
00502 for (i = k1; i < k2; i++) {
00503
00504 idx
00505 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes[i];
00506
00507
00508 if (coreConstraintIndexes.find(idx)
00509 == coreConstraintIndexes.end()) {
00510
00511 indexes[numNonz] = conMap[idx];
00512 values[numNonz]
00513 = m_osinstance->getLinearConstraintCoefficientsInColumnMajor()->values[i];
00514 numNonz++;
00515 }
00516
00517 }
00518 starts[kount + 1] = numNonz;
00519
00520 kount++;
00521
00522 }
00523
00524
00525
00526
00527 osinstance->setConstraintNumber(numberCon);
00528 conLowerBounds = new double[numberCon];
00529 conUpperBounds = new double[numberCon];
00530 conConstants = new double[numberCon];
00531
00532 for (mit = conMap.begin(); mit != conMap.end(); mit++) {
00533
00534 conLowerBounds[mit->second]
00535 = m_osinstance->getConstraintLowerBounds()[mit->first];
00536 conUpperBounds[mit->second]
00537 = m_osinstance->getConstraintUpperBounds()[mit->first];
00538 conConstants[mit->second] = 1.0;
00539
00540
00541
00542 }
00543
00544 std::cout << "Call setConstraints " << numberCon << std::endl;
00545
00546 osinstance->setConstraints(numberCon, conNames, conLowerBounds,
00547 conUpperBounds, conConstants);
00548
00549 osinstance->setLinearConstraintCoefficients(numNonz, true,
00550 values, 0, numNonz - 1, indexes, 0, numNonz - 1,
00551 starts, 0, numberVar);
00552
00553 }
00554
00555
00556
00557
00558
00559 m_blockOSInstances.push_back(osinstance);
00560
00561
00562
00563
00564
00565 objcoeff->bDeleteArrays = true;
00566 delete objcoeff;
00567 if (varLowerBounds != NULL)
00568 delete[] varLowerBounds;
00569 if (varUpperBounds != NULL)
00570 delete[] varUpperBounds;
00571 if (varTypes != NULL)
00572 delete[] varTypes;
00573 if (varNames != NULL)
00574 delete[] varNames;
00575
00576
00577
00578
00579
00580 if (conLowerBounds != NULL)
00581 delete[] conLowerBounds;
00582 if (conUpperBounds != NULL)
00583 delete[] conUpperBounds;
00584 if (conConstants != NULL)
00585 delete[] conConstants;
00586
00587 whichBlock++;
00588
00589 }
00590
00591
00592 }
00593
00594 catch (const ErrorClass& eclass) {
00595
00596 std::cout << eclass.errormsg << std::endl;
00597 throw ErrorClass(eclass.errormsg);
00598
00599 }
00600 m_blockOSInstancesProcessed = true;
00601 return m_blockOSInstances;
00602
00603 }
00604
00605 std::set<int> OS_DipInterface::getCoreConstraintIndexes() {
00606
00607
00608
00609 if (m_coreConstraintIndexesProcessed == true)
00610 return m_coreConstraintIndexes;
00611 try {
00612 if (m_osoption == NULL)
00613 throw ErrorClass("we have a null osoption");
00614
00615 int numCoreCon;
00616 int i;
00617 std::vector<OtherConstraintOption*> otherConstraintOptions;
00618 std::vector<OtherConstraintOption*>::iterator vit;
00619
00620 if (m_osoption != NULL
00621 && m_osoption->getNumberOfOtherConstraintOptions() > 0) {
00622
00623 otherConstraintOptions = m_osoption->getOtherConstraintOptions(
00624 "Dip");
00625
00626 for (vit = otherConstraintOptions.begin(); vit
00627 != otherConstraintOptions.end(); vit++) {
00628
00629
00630
00631 if (((*vit)->name.compare("constraintSet") == 0)
00632 && ((*vit)->type.compare("Core") == 0)) {
00633
00634 numCoreCon = (*vit)->numberOfCon;
00635
00636 for (i = 0; i < numCoreCon; i++) {
00637
00638 if ((*vit)->con[i]->idx
00639 >= m_osinstance->getConstraintNumber())
00640 throw ErrorClass(
00641 "found an invalid constraint index in OSoL file");
00642
00643 m_coreConstraintIndexes.insert((*vit)->con[i]->idx);
00644
00645 }
00646
00647 }
00648
00649
00650 }
00651
00652
00653 }
00654
00655 if (m_coreConstraintIndexes.size() <= 0)
00656 throw ErrorClass(
00657 "there were no core constraints listed in the option file");
00658 }
00659
00660
00661 catch (const ErrorClass& eclass) {
00662
00663 std::cout << eclass.errormsg << std::endl;
00664 throw ErrorClass(eclass.errormsg);
00665
00666 }
00667 m_coreConstraintIndexesProcessed = true;
00668 return m_coreConstraintIndexes;
00669
00670 }
00671
00672
00673 double* OS_DipInterface::getObjectiveFunctionCoeff() {
00674
00675
00676
00677 return m_osinstance->getDenseObjectiveCoefficients()[0];
00678 }
00679
00680
00682 OS_DipInterface::OS_DipInterface() :
00683
00684 m_isProvenOptimal(false), m_bestKnownLB(-1.e20), m_bestKnownUB(1.e20),
00685 m_coinpm(NULL), m_blockVariableIndexesProcessed(false),
00686 m_coreConstraintIndexesProcessed(false),
00687 m_blockConstraintIndexesProcessed(false),
00688 m_blockOSInstancesProcessed(false),
00689 m_blockFactoriesProcessed(false) {
00690
00691 }
00692
00693 OS_DipInterface::~OS_DipInterface() {
00694 std::cout << "INSIDE OS DIP INTERFACE DESTRUCTOR" << std::endl;
00695 if (m_osilreader != NULL)
00696 delete m_osilreader;
00697 if (m_osolreader != NULL)
00698 delete m_osolreader;
00699 delete m_coinpm;
00700
00701 std::vector<OSInstance*>::iterator vit;
00702
00703 if (m_blockOSInstances.size() > 0) {
00704 for (vit = m_blockOSInstances.begin(); vit != m_blockOSInstances.end(); vit++) {
00705
00706 delete *vit;
00707 }
00708 }
00709 }
00710
00711
00712
00713 std::map<int, std::vector< int> > OS_DipInterface::generateInitialMaster(){
00714
00715
00716
00717 FileUtil *fileUtil = NULL;
00718 OSiLReader *osilreader = NULL;
00719 DefaultSolver *solver = NULL;
00720 OSInstance *osinstance = NULL;
00721 OSOption *osoption = NULL;
00722
00723
00724
00725 std::string testFileName;
00726 std::string osil;
00727
00728
00729 std::map<int, std::vector< int> > indexMap;
00730 std::vector< int> indexes;
00731 fileUtil = new FileUtil();
00732
00733
00734 try {
00735 testFileName = "../data/restrictedMaster5.osil";
00736
00737 osil = fileUtil->getFileAsString(testFileName.c_str());
00738
00739 #ifdef MY_DEBUG
00740 std::cout << "Done reading the file" << std::endl;
00741 #endif
00742
00743 osilreader = new OSiLReader();
00744
00745
00746 osoption = new OSOption();
00747
00748 #ifdef MY_DEBUG
00749 parsingTestResult << "Reading files successfully" << std::endl;
00750 #endif
00751
00752 osinstance = osilreader->readOSiL(osil);
00753
00754 solver = new CoinSolver();
00755 solver->sSolverName ="cbc";
00756 solver->osinstance = osinstance;
00757 solver->osoption = osoption;
00758 std::cout << "CALLING SOLVE FOR RESTRICTED MASTER" << std::endl;
00759 solver->solve();
00760 int i;
00761 int j;
00762 int k;
00763 int vecSize;
00764
00765 std::vector<IndexValuePair*> primalValPair;
00766 primalValPair = solver->osresult->getOptimalPrimalVariableValues( 0);
00767 vecSize = primalValPair.size();
00768
00769
00770 int numNodes = 5;
00771 int numHubs = 1;
00772 int totalDemand = 4;
00773
00774
00775
00776 int* routeDemand = NULL;
00777 int startPnt;
00778
00779 routeDemand = new int[ numHubs];
00780 int kount;
00781
00782 std::string* varNames;
00783 varNames = osinstance->getVariableNames();
00784
00785
00786 kount = 0;
00787 for(k = 0; k < numHubs; k++){
00788
00789 routeDemand[k ] = primalValPair[ kount]->value;
00790
00791 std::cout << "Route Demand = " << routeDemand[k] << std::endl;
00792 kount++;
00793
00794 }
00795
00796
00797
00798 for(k = 0; k < numHubs; k++){
00799
00800 startPnt = k*totalDemand*(numNodes*numNodes - numNodes) + (routeDemand[ k] - 1)*(numNodes*numNodes - numNodes);
00801
00802 for(i = 0; i < numNodes; i++){
00803
00804
00805 for(j = 0; j < i; j++){
00806
00807 if( primalValPair[ kount]->value > .1){
00808
00809 std::cout << varNames[ kount] << std::endl;
00810 indexes.push_back(startPnt + i*(numNodes-1) + j );
00811
00812
00813 }
00814
00815 kount++;
00816
00817 }
00818
00819 for(j = i + 1; j < numNodes; j++){
00820
00821
00822 if( primalValPair[ kount]->value > .1){
00823 std::cout << varNames[ kount] << std::endl;
00824 indexes.push_back(startPnt + i*(numNodes-1) + j -1 );
00825
00826
00827 }
00828
00829
00830 kount++;
00831
00832 }
00833
00834 }
00835
00836
00837
00838 indexMap.insert(make_pair(k, indexes));
00839
00840 }
00841
00842
00843 std::cout << "DONE CALLING SOLVE FOR RESTRICTED MASTER" << std::endl;
00844
00845
00846
00847 delete[] routeDemand;
00848
00849
00850 delete osilreader;
00851 osilreader = NULL;
00852 delete solver;
00853 solver = NULL;
00854 delete osoption;
00855 osoption = NULL;
00856
00857
00858 } catch (const ErrorClass& eclass) {
00859 cout << endl << endl << endl;
00860 if (osilreader != NULL)
00861 delete osilreader;
00862 if (solver != NULL)
00863 delete solver;
00864 if (osoption != NULL)
00865 delete osoption;
00866
00867 throw ErrorClass(eclass.errormsg);
00868 }
00869
00870 delete fileUtil;
00871 fileUtil = NULL;
00872 return indexMap;
00873
00874 }